【摘要】
如果各个线程之间各干各的，确实不需要通信，这样的代码也十分的简单。但这一般是不可能的，至少线程要和主线程进行通信，不然计算结果等内容无法取回。而实际情况中要复杂的多，多个线程间需要交换数据，才能得到正确的执行结果。因为GIL的限制，python的线程是无法真正意义上并行的。相对于异步编程，其性能可以说不是一个等量级的。为什么我们还要学习多线程编程呢，虽然说异步编程好处多，但编程也较为复杂，逻辑不容易理解，学习成本和维护成本都比较高。毕竟我们大部分人还是适应同步编码的，除非一些需要高性能处理的地方采用异步
【正文】
一锁机制
1.1互斥锁(Lock)
如果多个线程对某一资源同时进行修改，可能会存在不可预知的情况。为了修改数据的正确性，需要把这个资源锁住，只允许线程依次排队进去获取这个资源。当线程A操作完后，释放锁，线程B才能进入。如下脚本是开启多个线程修改变量的值，但输出结果每次都不一样
importthreading
money =0defOrder(n):globalmoney
money = money + n
money = money - nclassthread(threading.Thread):def__init__(self,threadname):
threading.Thread.__init__(self,name='线程'+ threadname)self.threadname =int(threadname)defrun(self):foriinrange(1000000):
Order(self.threadname)if__name__ =='__main__':
t1 = thread('1')
t2 = thread('5')
t1.start()
t2.start()
t1.join()
t2.join()print(money)接下来我们用 threading.Lock() 锁住这个变量，等操作完再释放这个锁。lock.acquire() 给资源加一把锁，对资源处理完成之后，lock.release() 再释放锁。以下脚本执行结果都是一样的，但速度会变慢，因为线程只能一个个的通过。importthreading
money =0defOrder(n):globalmoney
money = money + n
money = money - nclassthread(threading.Thread):def__init__(self,threadname):
threading.Thread.__init__(self,name='线程'+ threadname)self.threadname =int(threadname)defrun(self):foriinrange(1000000):
lock.acquire()
Order(self.threadname)
lock.release()if__name__ =='__main__':
lock = threading.Lock()
t1 = thread('1')
t2 = thread('5')
t1.start()
t2.start()
t1.join()
t2.join()print(money)
1.2递归锁(RLock)
用法和 threading Lock() 一致，区别是 threading.Rlock() 允许多次锁资源，acquire() 和 release() 必须成对出现，也就是说加了几把锁就得释放几把锁。lock = threading.Lock()# 死锁lock.acquire()
lock.acquire()print('...')
lock.release()
lock.release()
rlock = threading.RLock()# 同一线程内不会阻塞线程rlock.acquire()
rlock.acquire()print('...')
rlock.release()
rlock.release()
二条件变量
2
2.1Condition()threading.Condition() 可以理解为更加高级的锁，比 Lock 和 Rlock 的用法更高级，能处理一些复杂的线程同步问题。threading.Condition() 创建一把资源锁(默认是Rlock)，提供 acquire() 和 release() 方法，用法和 Rlock 一致。此外 Condition 还提供 wait()、Notify() 和 NotifyAll() 方法。
Øwait()：线程挂起，直到收到一个 Notify() 通知或者超时(可选参数)，wait() 必须在线程得到 Rlock 后才能使用。
ØNotify() ：在线程挂起的时候，发送一个通知，让 wait() 等待线程继续运行，Notify() 也必须在线程得到 Rlock 后才能使用。 Notify(n=1)，最多唤醒 n 个线程。
ØNotifyAll() ：在线程挂起的时候，发送通知，让所有 wait() 阻塞的线程都继续运行。举例说明下 Condition() 使用importthreading,timedefTestA():
cond.acquire()print('李白：看见一个敌人，请求支援')
cond.wait()print('李白：好的')
cond.notify()
cond.release()defTestB():
time.sleep(2)
cond.acquire()print('亚瑟：等我...')
cond.notify()
cond.wait()print('亚瑟：我到了，发起冲锋...')if__name__=='__main__':
cond = threading.Condition()
testA = threading.Thread(target=TestA)
testB = threading.Thread(target=TestB)
testA.start()
testB.start()
testA.join()
testB.join()# --- 输出 ---
# 李白：看见一个敌人，请求支援
# 亚瑟：等我...
# 李白：好的
# 亚瑟：我到了，发起冲锋...
三事件
1
2
3
3.1Event()同进程的一样，线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
threading.Event() 原理是在线程中立了一个 Flag，默认值是 False ，当一个或多个线程遇到 event.wait() 方法时阻塞，直到 Flag 值 变为 True。threading.Event() 通常用来实现线程之间的通信，使一个线程等待其他线程的通知，把 Event 传递到线程对象中。
Øevent.wait() ：阻塞线程，直到 Flag 值变为 True
Øevent.set() ：设置 Flag 值为 True
Øevent.clear() ：修改 Flag 值为 False
Øevent.isSet() : 仅当 Flag 值为 True 时返回
下面这个例子，主线程启动子线程后 sleap 2秒，子线程因为 event.wait() 被阻塞。当主线程醒来后执行 event.set() ，子线程才继续运行，两者输出时间差 2s。importthreadingimportdatetime,timeclassthread(threading.Thread):def__init__(self,threadname):
threading.Thread.__init__(self,name='线程'+ threadname)self.threadname =int(threadname)defrun(self):
event.wait()print('子线程运行时间：%s'%datetime.datetime.now())if__name__ =='__main__':
event = threading.Event()
t1 = thread('0')#启动子线程t1.start()print('主线程运行时间：%s'%datetime.datetime.now())
time.sleep(2)# Flag设置成Trueevent.set()
t1.join()# --- 输出 ---
# 主线程运行时间：2019-05-30 15:51:49.690872
# 子线程运行时间：2019-05-30 15:51:51.691523
