Python thread (线程)
线程 (thread)
操作系统最小的调度单位，是一串指令的集合
程序一开始就有一个主线程，新启动的线程和主线程之间互不影响，主线程启动子线程之后就相互独立（子线程也可以启动线程），无论子线程是否执行结束主线程都会继续执行，程序在所有线程执行结束后关闭
全局解释器锁 (GIL)
由于无法控制线程执行顺序，为了防止数据出现错误，通过 GIL 使同一时间只有一个线程在工作
需要明确的一点是 GIL 并不是 Python 的特性，它是在实现 Python 解析器 (CPython) 时所引入的一个概念，Python 完全可以不依赖 GIL
threading 模块
启动线程
直接调用
示例：
import threading
import time
def 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 threading
class 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 time
def run(i):
print('test', i)
time.sleep(1)
run('t1')
run('t2')
run('t3')
与多线程对比可以发现：多线程是 print 之后等待 1s 之后结束，而单线程每次 print 之后都要等待。
其他
join
主线程创建子线程之后，主线程就与子线程相互独立，不管子线程是否执行完成，主线程都会继续执行下去
使用 join 可以让主线程等待子线程执行完成之后，再继续执行
示例：
import threading
import time
def 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 time
def 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 time
def 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 threading
def run1():
lock.acquire()
global num1
num1 += 1
lock.release()
return num1
def run2():
lock.acquire()
global num2
num2 += 1
lock.release()
return num2
def 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 threading
def run1():
lock.acquire()
global num1
num1 += 1
lock.release()
return num1
def run2():
lock.acquire()
global num2
num2 += 1
lock.release()
return num2
def 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 sys
def 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 time
event = 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()
