多线程

多线程的概念与 Python 实现

每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
每个线程都有他自己的一组 CPU 寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的 CPU 寄存器的状态。
指令指针和堆栈指针寄存器是线程上下文中两个最重要的寄存器，线程总是在进程得到上下文中运行的，这些地址都用于标志拥有线程的进程地址空间中的内存。
线程可以被抢占（中断）。
在其他线程正在运行时，线程可以暂时搁置（也称为睡眠） – 这就是线程的退让。
线程可以分为:
内核线程：由操作系统内核创建和撤销。
用户线程：不需要内核支持而在用户程序中实现的线程。
Python3 线程中常用的两个模块为：
_thread
threading(推荐使用)
thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用”thread” 模块。为了兼容性，Python3 将 thread 重命名为 “_thread”。

_thread 模块

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

基本理论

调用 _thread 模块中的 start_new_thread()函数来产生新线程，语法如下：

1
_thread.start_new_thread ( function, args[, kwargs] )

参数说明:
function - 线程函数。
args - 传递给线程函数的参数,他必须是个 tuple 类型。
kwargs - 可选参数。

代码示例

创建两个线程并同时执行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# 创建两个线程
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: 无法启动线程")

while 1:
   pass

threading 模块

推荐使用 threading 模块来使用多线程

基本理论

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

threading. current_thread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的列表。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.active_count(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果。
threading.Thread(target, args=(), kwargs={}, daemon=None)：
创建 Thread 类的实例。
target：线程将要执行的目标函数。
args：目标函数的参数，以元组形式传递。
kwargs：目标函数的关键字参数，以字典形式传递。
daemon：指定线程是否为守护线程。
threading.Thread 类提供了以下方法与属性:

init(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)：

初始化 Thread 对象。
group：线程组，暂时未使用，保留为将来的扩展。
target：线程将要执行的目标函数。
name：线程的名称。
args：目标函数的参数，以元组形式传递。
kwargs：目标函数的关键字参数，以字典形式传递。
daemon：指定线程是否为守护线程。
start(self)：

启动线程。将调用线程的 run()方法。
run(self)：

线程在此方法中定义要执行的代码。
join(self, timeout=None)：

等待线程终止。默认情况下，join()会一直阻塞，直到被调用线程终止。如果指定了 timeout 参数，则最多等待 timeout 秒。
is_alive(self)：

返回线程是否在运行。如果线程已经启动且尚未终止，则返回 True，否则返回 False。
getName(self)：

返回线程的名称。
setName(self, name)：

设置线程的名称。
ident 属性：

线程的唯一标识符。
daemon 属性：

线程的守护标志，用于指示是否是守护线程。
isDaemon()方法：

代码示例

一个简单的线程示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(i)

# 创建线程
thread = threading.Thread(target=print_numbers)

# 启动线程
thread.start()

# 等待线程结束
thread.join()

线程同步

如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。
考虑这样一种情况：一个列表里所有元素都是 0，线程 “set” 从后向前把所有元素改成 1，而线程 “print” 负责从前往后读取列表并打印。
那么，可能线程”set”开始改的时候，线程”print”便来打印列表了，输出就成了一半 0 一半 1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。

基本理论

使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。

代码示例

创建继承自 threading.Thread 类的 myThread 类，在 run()的时候使用锁机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.delay, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")