Python thread (线程)

线程 (thread)

操作系统最小的调度单位，是一串指令的集合

程序一开始就有一个主线程，新启动的线程和主线程之间互不影响，主线程启动子线程之后就相互独立（子线程也可以启动线程），无论子线程是否执行结束主线程都会继续执行，程序在所有线程执行结束后关闭

全局解释器锁 (GIL)

由于无法控制线程执行顺序，为了防止数据出现错误，通过 GIL 使同一时间只有一个线程在工作

需要明确的一点是 GIL 并不是 Python 的特性，它是在实现 Python 解析器 (CPython) 时所引入的一个概念，Python 完全可以不依赖 GIL

threading 模块

启动线程

直接调用

示例：

import threading
import timedef run(i):# 函数名随意
print('test', i)
time.sleep(1)t1 = threading.Thread(target=run, args=('t1',))
t2 = threading.Thread(target=run, args=('t2',))
t3 = threading.Thread(target=run, args=('t3',))
t1.start()
t2.start()
t3.start()

threading.Thread(target=run, args=('t1',)) 中 target 为线程执行的函数，args 中为传入的参数

继承式调用

示例：

import threadingclass MyThread(threading.Thread):
def __init__(self, n):
super(MyThread, self).__init__()
self.n = n def run(self):# 函数名必须是 run
print('class test', self.n)t1 = MyThread('t1')
t2 = MyThread('t2')
t3 = MyThread('t3')
t1.start()
t2.start()
t3.start()

注意：如果需要获得线程执行函数的返回值，可以将返回值放入队列，再从队列中获取 (关于 Python 队列 <- 点击查看)

多线程与单线程区别

IO 操作不占用 CPU，计算占用 CPU

Python 多线程不适合 CPU 密集操作型的任务，适合 IO 操作密集型的任务

单线程示例：

import threading
import timedef run(i):
print('test', i)
time.sleep(1)run('t1')
run('t2')
run('t3')

与多线程对比可以发现：多线程是 print 之后等待 1s 之后结束，而单线程每次 print 之后都要等待。

其他

join

主线程创建子线程之后，主线程就与子线程相互独立，不管子线程是否执行完成，主线程都会继续执行下去

使用 join 可以让主线程等待子线程执行完成之后，再继续执行

示例：

import threading
import timedef run(th):
print('test', th)
time.sleep(2)start_time = time.time()
threading_list = []
num = 0
for i in range(50):
t = threading.Thread(target=run, args=('t-%s' % i,))
t.start()
threading_list.append(t)
for item in threading_list:
item.join()
print('totally', time.time() - start_time)

如果不使用 join 主线程在创建子线程之后就会继续执行，直接输出时间。再等待两秒，所有线程执行结束后程序结束

使用 join 后主线程会等待相应子线程全部执行结束之后再输出时间

守护线程(deamon)

守护线程是为主线程服务的，只要非守护线程执行完成程序就会直接结束

当一个子线程被设置为守护线程，程序就不会再等待他执行完成再结束

示例：

import threading
import timedef run(th):
print('test', th)
time.sleep(2)start_time = time.time()
num = 0
for i in range(50):
t = threading.Thread(target=run, args=('t-%s' % i,))
t.setDaemon(True)
t.start()
print('totally', time.time() - start_time)

注意：setDeamon(true) 需要在 start 之前设置

线程锁（互斥锁）

一个进程下可以启动多个线程，多个线程共享父进程的内存空间，也就意味着每个线程可以访问同一份数据。

此时，如果多个线程同时修改同一份数据，就会出错

已经有 GIL 为什么还会出错：

虽然已经有 GIL 保证同一时刻只有一个线程在修改数据，但是当某个进程在获取数据修改，还没保存修改的结果前 release GIL ，这时就会出错

import threading
import timedef run(th):
lock.acquire()# 获取锁
global num
time.sleep(0.01)
num += 1
print('test', th)
lock.release() # 释放锁lock = threading.Lock()
start_time = time.time()
threading_list = []
num = 0
for i in range(50):
t = threading.Thread(target=run, args=('t-%s' % i,))
t.start()
threading_list.append(t)
for item in threading_list:
item.join()
print(num)

注意：每个线程执行时间不能过长，否则就变成串行了

死锁

当有多层互斥锁同时存在时会出现死锁，程序进入死循环

import threadingdef run1():
lock.acquire()
global num1
num1 += 1
lock.release()
return num1def run2():
lock.acquire()
global num2
num2 += 1
lock.release()
return num2def run3():
lock.acquire()
res1 = run1()
res2 = run2()
lock.release()
print(res1, res2)num1, num2 = 0, 0
lock = threading.Lock()
for i in range(10):
t = threading.Thread(target=run3)
t.start()while threading.active_count() != 1:
print(threading.active_count())
else:
print('-----finished-----')
print(num1, num2)

RLock 递归锁

为了避免死锁，就需要使用递归锁 RLock

import threadingdef run1():
lock.acquire()
global num1
num1 += 1
lock.release()
return num1def run2():
lock.acquire()
global num2
num2 += 1
lock.release()
return num2def run3():
lock.acquire()
res1 = run1()
res2 = run2()
lock.release()
print(res1, res2)num1, num2 = 0, 0
lock = threading.RLock()
for i in range(10):
t = threading.Thread(target=run3)
t.start()while threading.active_count() != 1:
print(threading.active_count())
else:
print('-----finished-----')
print(num1, num2)

Semaphore (信号量)

互斥锁同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据

import threading
import time
import sysdef run(th):
semaphore.acquire()
string = 'threading:' + str(th) + '\n'
sys.stdout.write(string)
time.sleep(2)
semaphore.release()semaphore = threading.BoundedSemaphore(5)# 最多允许5个线程同时运行
for i in range(20):
t = threading.Thread(target=run, args=(i, ))
t.start()while threading.active_count() != 1:
pass
else:
print('Done')

从程序的运行过程可以看出：开始有5个线程在运行，这5个线程结束之后又有5个线程启动

Event (事件)

Event 可以让线程间进行交互，与设置全局变量同理

Event 借助internal flag有两种状态：True、False通过set、clear改变状态，线程通过is_set()获取 Event 状态，wait()在False时会阻塞

红绿灯与汽车交互示例：

import threading
import timeevent = threading.Event()def light():
count = 0
event.set()
while 1:
if 5 < count < 10:
event.clear()
print('red')
elif count == 10:
event.set()
print('green')
count = 0
else:
print('green')
count += 1
time.sleep(1)def car():
while 1:
if event.is_set():
print('running...')
time.sleep(1)
else:
print('waiting')
event.wait()l1 = threading.Thread(target=light,)
l1.start()
c1 = threading.Thread(target=car,)
c1.start()