Python--同步锁(互斥锁)、死锁(状态)、递归锁、信号量、Event对象
同步锁/互斥锁 (Lock)
import time import threading def sub(): global num #在每个线程中都获取这个全局变量 #num-=1 temp=num time.sleep(0.1) num =temp-1 # 对此公共变量进行-1操作 num = 100 #设定一个共享变量 thread_list = [] for i in range(100): t = threading.Thread(target=sub) t.start() thread_list.append(t) for t in thread_list: #等待所有线程执行完毕 t.join() print('Result: ', num) 运行结果: 99
我们想要的结果是多线程实现递减至0 ,但是很明显没有实现。
下面这段代码更改了一下睡眠时间,依然结果不会是0 。
import time import threading def sub(): global num #在每个线程中都获取这个全局变量 #num-=1 temp=num time.sleep(0.001) num =temp-1 # 对此公共变量进行-1操作 num = 100 #设定一个共享变量 thread_list = [] for i in range(100): t = threading.Thread(target=sub) t.start() thread_list.append(t) for t in thread_list: #等待所有线程执行完毕 t.join() print('Result: ', num) 运行结果: 大于0 但是小于100的数
锁通常被用来实现对共享资源的同步访问。
import threading R=threading.Lock() #为每一个共享资源创建一个Lock对象 R.acquire() #当你需要访问该资源时,调用acquire方法来获取锁对象(如果其它线程已经获得了该锁,则当前线程需等待其被释放) ''' 对公共数据的操作 ''' R.release() #待资源访问完后,再调用release方法释放锁:
import time import threading def sub(): global num #在每个线程中都获取这个全局变量 lock.acquire() temp=num time.sleep(0.001) num =temp-1 # 对此公共变量进行-1操作 lock.release() num = 100 #设定一个共享变量 thread_list = [] lock=threading.Lock() for i in range(100): t = threading.Thread(target=sub) t.start() thread_list.append(t) for t in thread_list: #等待所有线程执行完毕 t.join() print('Result: ', num) 运行结果: Result: 0
这样就解决了我们的问题。
为什么有了GIL,还需要线程同步? 多线程环境下必须存在资源的竞争,那么如何才能保证同一时刻只有一个线程对共享资源进行存取? 加锁, 对, 加锁可以保证存取操作的唯一性, 从而保证同一时刻只有一个线程对共享数据存取.
死锁与递归锁
import time import threading class Mythread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): self.foo() def foo(self): locka.acquire() print('I am %s got locka---%s'%(self.name,time.ctime())) lockb.acquire() print('I am %s got lockb---%s'%(self.name,time.ctime())) lockb.release() locka.release() if __name__ == '__main__': locka=threading.Lock() lockb=threading.Lock() for i in range(10): t=Mythread() t.start() 运行效果: I am Thread-1 got locka---Fri Jul 21 14:30:32 2017 I am Thread-1 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-2 got locka---Fri Jul 21 14:30:32 2017 I am Thread-2 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-3 got locka---Fri Jul 21 14:30:32 2017 I am Thread-3 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-4 got locka---Fri Jul 21 14:30:32 2017 I am Thread-4 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-5 got locka---Fri Jul 21 14:30:32 2017 I am Thread-5 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-6 got locka---Fri Jul 21 14:30:32 2017 I am Thread-6 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-7 got locka---Fri Jul 21 14:30:32 2017 I am Thread-7 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-8 got locka---Fri Jul 21 14:30:32 2017 I am Thread-8 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-9 got locka---Fri Jul 21 14:30:32 2017 I am Thread-9 got lockb---Fri Jul 21 14:30:32 2017 I am Thread-10 got locka---Fri Jul 21 14:30:32 2017 I am Thread-10 got lockb---Fri Jul 21 14:30:32 2017
所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程。
import time import threading class Mythread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): self.foo() self.bar() def foo(self): locka.acquire() print('I am %s got locka---%s'%(self.name,time.ctime())) lockb.acquire() print('I am %s got lockb---%s'%(self.name,time.ctime())) lockb.release() locka.release() def bar(self): lockb.acquire() print('I am %s got lockb---%s'%(self.name,time.ctime())) locka.acquire() print('I am %s got locka---%s'%(self.name,time.ctime())) locka.release() lockb.release() if __name__ == '__main__': locka=threading.Lock() lockb=threading.Lock() for i in range(10): t=Mythread() t.start()
运行效果图:
解决死锁状态的递归锁出现了。
在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:
import time import threading class Mythread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): self.foo() self.bar() def foo(self): Rlock.acquire() print('I am %s got locka---%s'%(self.name,time.ctime())) Rlock.acquire() print('I am %s got lockb---%s'%(self.name,time.ctime())) Rlock.release() Rlock.release() def bar(self): Rlock.acquire() print('I am %s got lockb---%s'%(self.name,time.ctime())) Rlock.acquire() print('I am %s got locka---%s'%(self.name,time.ctime())) Rlock.release() Rlock.release() if __name__ == '__main__': Rlock=threading.RLock() for i in range(10): t=Mythread() t.start() 运行效果: I am Thread-1 got locka---Fri Jul 21 14:42:08 2017 I am Thread-1 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-2 got locka---Fri Jul 21 14:42:08 2017 I am Thread-2 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-2 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-2 got locka---Fri Jul 21 14:42:08 2017 I am Thread-1 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-1 got locka---Fri Jul 21 14:42:08 2017 I am Thread-3 got locka---Fri Jul 21 14:42:08 2017 I am Thread-3 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-4 got locka---Fri Jul 21 14:42:08 2017 I am Thread-4 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-5 got locka---Fri Jul 21 14:42:08 2017 I am Thread-5 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-3 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-3 got locka---Fri Jul 21 14:42:08 2017 I am Thread-6 got locka---Fri Jul 21 14:42:08 2017 I am Thread-6 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-6 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-6 got locka---Fri Jul 21 14:42:08 2017 I am Thread-4 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-4 got locka---Fri Jul 21 14:42:08 2017 I am Thread-7 got locka---Fri Jul 21 14:42:08 2017 I am Thread-7 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-7 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-7 got locka---Fri Jul 21 14:42:08 2017 I am Thread-9 got locka---Fri Jul 21 14:42:08 2017 I am Thread-9 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-9 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-9 got locka---Fri Jul 21 14:42:08 2017 I am Thread-5 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-5 got locka---Fri Jul 21 14:42:08 2017 I am Thread-10 got locka---Fri Jul 21 14:42:08 2017 I am Thread-10 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-10 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-10 got locka---Fri Jul 21 14:42:08 2017 I am Thread-8 got locka---Fri Jul 21 14:42:08 2017 I am Thread-8 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-8 got lockb---Fri Jul 21 14:42:08 2017 I am Thread-8 got locka---Fri Jul 21 14:42:08 2017
Semaphore(信号量)
Semaphore管理一个内置的计数器,
每当调用acquire()时内置计数器-1;
调用release() 时内置计数器+1;
计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。
实例:(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5):
import threading import time semaphore =threading.Semaphore(5) #同时只有5个线程可以获得semaphore,即可以限制最大连接数为5 def foo(): semaphore.acquire() time.sleep(2) print('ok') semaphore.release() for i in range(10): t=threading.Thread(target=foo) t.start() 运行效果: 先同时打印5个‘ok’,过两秒再同时打印5个‘ok’
Event对象
线程的一个关键特性是每个线程都是独立运行且状态不可预测。
如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就 会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。
在 初始情况下,Event对象中的信号标志被设置为假。
如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。
一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。
如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
event.isSet():返回event的状态值; event.wait():如果 event.isSet()==False将阻塞线程; event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态, 等待操作系统调度; event.clear():恢复event的状态值为False。
import threading,time event=threading.Event() def foo(): print('waitting...') event.wait() print('connect to redis server') for i in range(5): t=threading.Thread(target=foo) t.start() print('attempt to start redis server') time.sleep(3) event.set() 运行效果: 先同时打印5个'waiting'和'attempt to start redis server',3秒后打印5个'connect to redis server'
threading.Event的wait方法还接受一个超时参数,默认情况下如果事件一直没有发生,wait方法会一直阻塞下去,而加入这个超时参数之后,如果阻塞时间超过这个参数设定的值之后,wait方法会返回。
import threading,time event=threading.Event() def foo(): print('waitting...') event.wait(1) print('cinnect to redis server') for i in range(5): t=threading.Thread(target=foo) t.start() print('attempt to start redis server') time.sleep(3) event.set() 运行效果: 先同时打印5个‘waitting’,1个‘attempt to start redis server’,过1秒打印'cinnect to redis server',再过两秒程序运行结束
- Python3之多线程GIL、同步锁、信号量、死锁与递归锁、线程Queue、Event、定时器
- python多线程,event,互斥锁,死锁,递归锁,信号量
- python并发编程之多线程2------------死锁与递归锁,信号量等
- Python进阶(3)_进程与线程中的lock(线程中互斥锁、递归锁、信号量、Event对象、队列queue)
- python并发编程之多线程2------------死锁与递归锁,信号量等
- python多线程编程: 使用互斥锁同步线程
- 线程介绍,线程几个方法,状态,Runnable接口,同步,死锁
- python使用互斥锁同步线程
- python多线程编程(3): 使用互斥锁同步线程
- 内核同步机制-信号量/互斥锁/读-写信号量 sema ,mutex ,rwsem
- python基础-死锁、递归锁
- python多线程编程(3): 使用互斥锁同步线程
- 信春哥!Python递归原地满状态变显式堆栈!入教即送尾递归优化!
- 16.进程同步与死锁——进程同步与信号量
- 举例讲解Python中的死锁、可重入锁和互斥锁
- 信号量(semaphore),互斥锁(mutex)解决哲学家死锁问题
- python多线程编程(3): 使用互斥锁同步线程
- python多线程编程: 使用互斥锁同步线程
- Python系列之死锁现象和递归锁
- 15章 进程间通信之同步(互斥锁、条件变量、读写锁、信号量)