基于线程的并发
| 基于线程的并发 |
一、什么是线程
线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程。 车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线。流水线的工作需要电源，电源就相当于cpu。所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。
二、线程与进程区别
- 线程共享创建进程的地址空间；进程有自己的地址空间；
- 线程可以直接访问进程的数据段；进程有自己的父进程数据段的副本；
- 线程可以直接与进程的其他线程通信；进程必须使用进程间通信来与同级进程通信；
- 新线程很容易创建；新进程需要复制父进程；
- 线程可以对同一进程的线程进行相当大的控制；进程只能对子进程进行控制；
- 更改主线程(取消、优先级更改等)可能会影响进程的其他线程的行为；父进程的更改不会影响子进程。
三、线程的创建开销小
线程的创建开销小还是进程的创建开销小？
假如我们是一个工厂，该工厂有多条流水线，流水线工作需要电源，电源只有一个即cpu（单核cpu）。一个车间就是一个进程，一个车间至少一条流水线（一个进程至少一个线程）。创建一个进程，就是创建一个车间（申请空间，在该空间内建至少一条流水线）。而建线程，就只是在一个车间内造一条流水线，无需申请空间，所以创建开销小。
四、多线程
多线程指的是，在一个进程中开启多个线程，简单的讲：如果多个任务共用一块地址空间，那么必须在一个进程内开启多个线程。详细的讲分为4点：
- 多线程共享一个进程的地址空间；
- 线程比进程更轻量级，线程比进程更容易创建可撤销，在许多操作系统中，创建一个线程比创建一个进程要快10-100倍，在有大量线程需要动态和快速修改时，这一特性很有用；
- 若多个线程都是cpu密集型的，那么并不能获得性能上的增强，但是如果存在大量的计算和大量的I/O处理，拥有多个线程允许这些活动彼此重叠运行，从而会加快程序执行的速度；
- 在多cpu系统中，为了最大限度的利用多核，可以开启多个线程，比开进程开销要小的多。（这一条并不适用于python）
利用多线程举个应用例子：比如开启一个字处理软件进程，该进程肯定需要办不止一件事情，比如监听键盘输入，处理文字，定时自动将文字保存到硬盘，这三个任务操作的都是同一块数据，因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程，那就只能是，键盘输入时，不能处理文字和自动保存，自动保存时又不能输入和处理文字。
五、创建线程
创建进程需要用到threading模块下Thread类，与创建进程multiprocess模块下Process类在使用层面上具有很大的相似性。因而不在详细介绍。
创建线程的两种方式：
import threading import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=threading.Thread(target=sayhi,args=('egon',)) t.start() print('主线程')
import threading import time class Sayhi(threading.Thread): def __init__(self,name): super().__init__() self.name=name def run(self): time.sleep(2) print('%s say hello' % self.name) if __name__ == '__main__': t = Sayhi('egon') t.start() print('主线程')
我们可以利用多线程把socket通信变成并发的形式：
import threading import socket s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.bind(('127.0.0.1',8080)) s.listen(5) def action(conn): while True: data=conn.recv(1024) print(data) conn.send(data.upper()) if __name__ == '__main__': while True: conn,addr=s.accept() p=threading.Thread(target=action,args=(conn,)) p.start()
import socket s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.connect(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if not msg:continue s.send(msg.encode('utf-8')) data=s.recv(1024) print(data)
我们利用多线程处理三个任务，一个接收用户输入，一个将用户输入的内容格式化成大写，一个将格式化后的结果存入文件。代码如下：
import threading msg_l=[] format_l=[] def talk(): while True: msg=input('>>: ').strip() if not msg:continue msg_l.append(msg) def format_msg(): while True: if msg_l: res=msg_l.pop() format_l.append(res.upper()) def save(): while True: if format_l: with open('db.txt','a',encoding='utf-8') as f: res=format_l.pop() f.write('%s\n' %res) if __name__ == '__main__': t1=threading.Thread(target=talk) t2=threading.Thread(target=format_msg) t3=threading.Thread(target=save) t1.start() t2.start() t3.start()
线程的一下方法介绍：
Thread实例对象的方法 #run():用来表示线程活动的方法 # start():启动线程活动 # isAlive():返回线程是否活动的 # getName():返回线程名 # setName():设置线程名 threading模块提供的一些方法： # threading.currentThread():返回当前的线程变量 # threading.enumerate():返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程 # threading.activeCount():返回正在运行的线程数量
下面我们来讲一下Thread类的实例join方法。它跟进程中join方法效果一样，其目的主线程等待子线程结束。
import threading import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=threading.Thread(target=sayhi,args=('egon',)) t.start() t.join() print('主线程')
六、守护线程
无论是进程还是线程，都遵循：守护线程(进程)会等待主线程(进程)运行完毕后被销毁。
需要强大的是：运行完毕并非终止运行。
#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束。 #2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
我们来创建一个简单的实例：
import threading import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=threading.Thread(target=sayhi,args=('egon',)) t.setDaemon(True) #必须在t.start()之前设置 t.start() print('主线程')
在上述代码中，只有一个线程，且被设置成守护线程，没有其他非守护线程，所以一执行代码守护线程就立刻被回收了。只打印"主线程"。
下面我们就来搞个有意思的例子：
import threading import time def foo(): print(123) time.sleep(1) print("end123") def bar(): print(456) time.sleep(3) print("end456") t1=threading.Thread(target=foo) t2=threading.Thread(target=bar) if __name__ == '__main__': t1.setDaemon(True) t1.start() t2.start() print("main-------")
执行代码一看，怎么守护线程的函数也打印了？原因是主线程要在其他线程运行完毕后才算运行完毕。只有当运行完毕后守护线程才会被回收。显然代码中的守护线程在主线程还没有运行完毕就执行成功了。不过等主线程执行完毕后马上被回收，只是我们看不到而已。
七、Python GIL
GIL就是全局解释锁，本质上是一把互斥锁，既然是互斥锁，所有互斥锁的本质都一样，都是将并发运行变成串行，以此来控制同一时间内共享数据只能被一个任务所修改，进而保证数据安全。
因为有GIL，同一个进程下开启的多线程，同一时刻只能有一个线程执行。
这样的话Python的多线程虽然开销小，但却无法利用多核优势。该怎么办？想要解决这个问题，我们需要在几个点上达成一致：
#1. cpu到底是用来做计算的，还是用来做I/O的？ #2. 多cpu，意味着可以有多个核并行完成计算，所以多核提升的是计算性能 #3. 每个cpu一旦遇到I/O阻塞，仍然需要等待，所以多核对I/O操作没什么用处
举个例子：一个工人相当于cpu，此时计算相当于工人在干活，I/O阻塞相当于为工人干活提供所需原材料的过程，工人干活的过程中如果没有原材料了，则工人干活的过程需要停止，直到等待原材料的到来。如果你的工厂干的大多数任务都要有准备原材料的过程（I/O密集型），那么你有再多的工人，意义也不大，还不如一个人，在等材料的过程中让工人去干别的活，反过来讲，如果你的工厂原材料都齐全，那当然是工人越多，效率越高。
通过这个例子可以得到些结论：对计算来说，cpu越多越好，但是对于I/O来说，再多的cpu也没用。当然对运行一个程序来说，随着cpu的增多执行效率肯定会有所提高（不管提高幅度多大，总会有所提高），这是因为一个程序基本上不会是纯计算或者纯I/O，所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型，从而进一步分析python的多线程到底有无用武之地。
#分析： 我们有四个任务需要处理，处理方式肯定是要玩出并发的效果，解决方案可以是： 方案一：开启四个进程 方案二：一个进程下，开启四个线程 #单核情况下，分析结果: 如果四个任务是计算密集型，没有多核来并行计算，方案一徒增了创建进程的开销，方案二胜 如果四个任务是I/O密集型，方案一创建进程的开销大，且进程的切换速度远不如线程，方案二胜 #多核情况下，分析结果： 如果四个任务是计算密集型，多核意味着并行计算，在python中一个进程中同一时刻只有一个线程执行用不上多核，方案一胜 如果四个任务是I/O密集型，再多的核也解决不了I/O问题，方案二胜
通过分析我们可以得到这样的结论：现在的计算机基本上都是多核，python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升，甚至不如串行(没有大量切换)，但是，对于IO密集型的任务效率还是有显著提升的。
八、同步锁
Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要同步锁(lock)?
首先我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据。所以得出的结论是保护不同的数据就应该加不同的锁。
过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限
线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。这就导致了串行运行的效果。既然是串行，那我们执行start方法和join方法，发现这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。
import threading,time num = 100 def sub(): global num temp = num time.sleep(0.0001) #IO操作，切换 num = temp - 1 l = [] for i in range(100): t = threading.Thread(target=sub) t.start() l.append(t) for t in l: t.join() print(num)
import threading,time num = 100 def sub(): global num lock.acquire() temp = num time.sleep(0.0001) #IO操作，切换 num = temp - 1 lock.release() l = [] lock = threading.Lock() for i in range(100): t = threading.Thread(target=sub) t.start() l.append(t) for t in l: t.join() print(num)
从执行结果来看未加锁的代码不为0，而加锁的代码为0，加锁的代码才符合我们预期的结果，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全。
锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁。
九、死锁与递归锁
所谓死锁是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。
import threading,time class MyTread(threading.Thread): def run(self): self.actionA() self.actionB() def actionA(self): A.acquire() print(self.name,'gotA',time.ctime()) time.sleep(2) B.acquire() print(self.name,'gotB',time.ctime()) time.sleep(1) B.release() A.release() def actionB(self): B.acquire() print(self.name,'gotB',time.ctime()) time.sleep(2) A.acquire() print(self.name,'gotA',time.ctime()) time.sleep(1) A.release() B.release() if __name__ == '__main__': A = threading.Lock() B = threading.Lock() l=[] for i in range(5): t = MyTread() t.start() l.append(t) for i in l: i.join() print('ending')
死锁解决方法就是递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁。
import threading,time class MyTread(threading.Thread): def run(self): self.actionA() self.actionB() def actionA(self): r_lock.acquire() print(self.name,'gotA',time.ctime()) time.sleep(2) r_lock.acquire() print(self.name,'gotB',time.ctime()) time.sleep(1) r_lock.release() r_lock.release() def actionB(self): r_lock.acquire() print(self.name,'gotB',time.ctime()) time.sleep(2) r_lock.acquire() print(self.name,'gotA',time.ctime()) time.sleep(1) r_lock.release() r_lock.release() if __name__ == '__main__': r_lock = threading.RLock() #递归锁 l=[] for i in range(5): t = MyTread() t.start() l.append(t) for i in l: i.join() print('ending')
十、信号量
信号量Semaphore管理一个内置的计数器，每当调用acquire()时内置计数器-1，调用release() 时内置计数器+1。计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
我们利用信号量来实现例子：
import threading,time class MyThread(threading.Thread): def run(self): if semaphore.acquire(): print(self.name) time.sleep(3) semaphore.release() if __name__ == '__main__': semaphore = threading.Semaphore(5) #只有5个线程可以获得semaphore thrs = [] for i in range(100): thrs.append(MyThread()) for t in thrs: t.start()
信号量与进程池是完全不同的概念，进程池Pool(4)，最大只能产生4个进程，而且从头到尾都只是这四个进程，不会产生新的，而信号量是产生一堆线程/进程。
十一、Event
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作，这时线程同步问题就会变得非常棘手。为了解决这些问题，我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志，它允许线程等待某些事件的发生。在 初始情况下，Event对象中的信号标志被设置为假。如果有线程等待一个Event对象， 而这个Event对象的标志为假，那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真，它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象，那么它将忽略这个事件, 继续执行。
Event对象的一些主要方法：
#event.wait() 等待标志位flag被设定，如果flag被设定，就不等了，往下执行。如果flag没被设定，相当于阻塞状态 #event.set() set设定flag #event.clear() clear清除flag #event.isSet()：返回event是否设定flag
举个例子，一家公司老板要求加班到22点，后面才会有员工抱怨，并不是先抱怨后才有的要求加班的。利用这个我们来实现：
import threading,time class Boss(threading.Thread): def run(self): print('BOSS:今晚大家都要加班到22:00') print(event.isSet()) event.set() time.sleep(5) print('BOSS:<22:00>可以下班了') print(event.isSet()) event.set() class Worker(threading.Thread): def run(self): event.wait() #一旦event被设定，等同于pass print('Worker:哎。。命苦啊') time.sleep(1) event.clear() event.wait() print('Worker:OhYeah!') if __name__ == '__main__': event = threading.Event() threads = [] for i in range(5): threads.append(Worker()) threads.append(Boss()) for t in threads: t.start() for t in threads: t.join() print('ending...')
十二、队列
线程队列使用import queue，用法跟进程Queue一样。
queue.Queue() 先进先出
queue.LifoQueue() 先进后出
queue.PriorityQueue() 存储数据时可设置优先级的队列，put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高。
我们实现一个先进先出的实例：
import queue #线程队列 q = queue.Queue() #FIFO模式(先进先出) q.put(12) q.put('hello') q.put({'name':'alex'}) print(q.qsize()) #队列大小 print(q.empty()) #是否为空 print(q.full) #是否为满 while 1: data = q.get() print(data) print('---------')
