为什么有这把GIL锁?
答:Python语言的创始人在开发这门语言时,目的快速把语言开发出来,如果加上GIL锁(C语言加锁),切换时按照100条字节指令来进行线程间的切换。
一.线程锁(Lock、RLock) (1次放1个)
由于线程之间是进行随机调度,并且每个线程可能只执行n条执行之后,当多个线程同时修改同一条数据时可能会出现脏数据,所以,出现了线程锁 - 同一时刻允许一个线程执行操作。
1.Lock (同步锁) 没有加锁
import threading import time v = [] lock = threading.Lock() def func(arg): v.append(arg) time.sleep(2) m = v[-1] print(arg,m) for i in range(10): t = threading.Thread(target=func,args=(i,)) t.start() #结果:0 9 1 9 4 9 3 9 2 9 6 9 5 9 9 9 8 9 7 9
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import threading import time v = [] lock = threading.Lock() def func(arg): lock.acquire() v.append(arg) time.sleep(2) m = v[-1] print(arg,m) lock.release() for i in range(10): t = threading.Thread(target=func,args=(i,)) t.start() #结果:0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
` 解决方法,递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:
2.RLock(一次放一个)( 递归锁 )
import threading import time v = [] lock = threading.RLock() def func(arg): lock.acquire() lock.acquire() v.append(arg) time.sleep(1) m = v[-1] print(arg,m) lock.release() lock.release() for i in range(10): t = threading.Thread(target=func,args=(i,)) t.start()
3.BoundedSemaphore(1次放N个)信号量
互斥锁 同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程更改数据 ,比如厕所有3个坑,那最多只允许3个人上厕所,后面的人只能等里面有人出来了才能再进去。
Semaphore管理一个内置的计数器,
每当调用acquire()时内置计数器-1;
调用release() 时内置计数器+1;
计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。
import threading import time lock = threading.BoundedSemaphore(3) def func(arg): lock.acquire() print(arg) time.sleep(1) lock.release() for i in range(10): t = threading.Thread(target=func,args=(i,)) t.start()
4.条件(Condition)(1次放动态N个)
使得线程等待,只有满足某条件时,才释放n个线程
import threading import time lock = threading.Condition() def func(arg): print('线程进来了') lock.acquire() lock.wait() # 加锁 print(arg) time.sleep(1) lock.release() for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start() while True: inp = int(input('>>>')) lock.acquire() lock.notify(inp) lock.release()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import threading import time lock = threading.Condition() def func1(): print('来执行函数了') input(">>>") # ct = threading.current_thread() # 获取当前线程 # ct.getName() return True def func(arg): print('线程进来了') lock.wait_for(func1) print(arg) time.sleep(1) for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start()
5.事件Event(1次放所有)
python线程的事件用于主线程控制其他线程的执行,事件主要提供了三个方法 set、wait、clear。
事件处理的机制:全局定义了一个“Flag”,如果“Flag”值为 False,那么当程序执行 event.wait 方法时就会阻塞,如果“Flag”值为True,那么event.wait 方法时便不再阻塞。
- clear:将“Flag”设置为False
- set:将“Flag”设置为True
event.isSet():返回event的状态值; event.wait():如果 event.isSet()==False将阻塞线程; event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态, 等待操作系统调度; event.clear():恢复event的状态值为False。
import threading lock = threading.Event() def func(arg): print('线程来了') lock.wait() # 加锁:红灯 print(arg) for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start() input(">>>>") lock.set() # 绿灯 lock.clear() # 再次变红灯 for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start() input(">>>>") lock.set()
总结:
线程安全,列表和字典是线程安全
为什么要加锁?
非线程安全
可以控制一段代码
二.threading.local
作用:内部自动为每一个线程维护一个空间(字典),用于当前存取属于自己的值,保证线程之间的数据隔离
import time import threading v = threading.local() def func(arg): # 内部会为当前线程创建一个空间用于存储:phone=自己的值 v.phone = arg time.sleep(2) print(v.phone,arg) # 去当前线程自己空间取值 for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start()
threading.local的原理
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import time import threading DATA_DICT = {} def func(arg): ident = threading.get_ident() DATA_DICT[ident] = arg time.sleep(1) print(DATA_DICT[ident],arg) for i in range(10): t =threading.Thread(target=func,args=(i,)) t.start()
三.线程池
进程池:就是在一个进程内控制一定个数的线程
基于concurent.future模块的进程池和线程池 (他们的同步执行和异步执行是一样的)
from concurrent.futures import ThreadPoolExecutor import time def task(a1,a2): time.sleep(2) print(a1,a2) # 创建了一个线程池(最多5个线程) pool = ThreadPoolExecutor(5) for i in range(40): # 去线程池中申请一个线程,让线程执行task函数。 pool.submit(task,i,8)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import threading import time def task(arg): time.sleep(10) while True: num = input(">>>") t = threading.Thread(target=task,args=(num,)) t.start()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import time from concurrent.futures import ThreadPoolExecutor def task(arg): time.sleep(5) pool = ThreadPoolExecutor(2) while True: num = input(">>>") pool.submit(task,num)
四.生产者消费者模型
1.三部件:
生产者 队列:先进先出 (栈:后进先出) 消费者
2.线程队列
queue队列 :使用import queue,用法与进程Queue一样
- class
queue.
Queue
(maxsize=0) #先进先出
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import queue q=queue.Queue() q.put('first') q.put('second') q.put('third') print(q.get()) print(q.get()) print(q.get()) ''' 结果(先进先出): first second third '''
class queue.
LifoQueue
(maxsize=0) #last in fisrt out
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import queue q=queue.LifoQueue() q.put('first') q.put('second') q.put('third') print(q.get()) print(q.get()) print(q.get()) ''' 结果(后进先出): third second first '''
class queue.
PriorityQueue
(maxsize=0) #存储数据时可设置优先级的队列
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import queue q=queue.PriorityQueue() #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高 q.put((20,'a')) q.put((10,'b')) q.put((30,'c')) print(q.get()) print(q.get()) print(q.get()) ''' 结果(数字越小优先级越高,优先级高的优先出队): (10, 'b') (20, 'a') (30, 'c') '''
3.生产者消费者模型解决了什么问题?
可以不用一直等待的问题
import time import queue import threading q = queue.Queue() # 线程安全 def producer(id): """ 生产者 :return: """ while True: time.sleep(2) q.put('包子') print('厨师%s 生产了一个包子' %id ) for i in range(1,4): t = threading.Thread(target=producer,args=(i,)) t.start() def consumer(id): """ 消费者 :return: """ while True: time.sleep(1) v1 = q.get() print('顾客 %s 吃了一个包子' % id) for i in range(1,3): t = threading.Thread(target=consumer,args=(i,)) t.start()