线程_锁 | 易学教程

（1）死锁

是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁

#死锁
from threading import Thread,Lock,current_thread
import time
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()
    def f1(self):
        mutexA.acquire()
        print("%s 抢到A锁" %current_thread().getName())
        mutexB.acquire()
        print("%s 抢到B锁" %current_thread().getName())
        print("%s 释放B锁" %current_thread().getName())
        mutexB.release()
        print("%s 释放A锁" %current_thread().getName())
        mutexA.release()
        
    def f2(self):
        mutexB.acquire()
        print("%s 抢到B锁" %current_thread().getName())
        time.sleep(1)
        mutexA.acquire()
        print("%s 抢到A锁" %current_thread().getName())
        print("%s 释放A锁" %current_thread().getName())
        mutexA.release()
        print("%s 释放B锁" %current_thread().getName())
        mutexB.release()
        
if __name__=="__main__":
    mutexA=Lock()
    mutexB=Lock()
    for i in range(20):
        t=MyThread()
        t.start()
# '''
# Thread-758 抢到A锁
# Thread-758 抢到B锁
# Thread-758 释放B锁
# Thread-758 释放A锁
# Thread-758 抢到B锁
# Thread-759 抢到A锁
# '''

（2）递归锁

RLock内部维护着一个Lock和一个counter变量，

counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

上面的例子如果使用RLock代替Lock，则不会发生死锁：

from threading import Thread,RLock,current_thread
import time
class MyThread(Thread):
    def run(self):
        self.f1()
        self.f2()
    def f1(self):
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        
    def f2(self):
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        time.sleep(1)
        mutex.acquire()
        print("%s 抢到锁" %current_thread().getName())
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        print("%s 释放锁" %current_thread().getName())
        mutex.release()
        
if __name__=="__main__":
    mutex=RLock()
    for i in range(20):
        t=MyThread()
        t.start()
'''
Thread-808 抢到锁
Thread-808 抢到锁
Thread-808 释放锁
Thread-808 释放锁
Thread-810 抢到锁
Thread-810 抢到锁
Thread-810 释放锁
Thread-810 释放锁

'''

（3）信号量

Semaphore管理一个内置的计数器，每当调用acquire()时内置计数器-1；调用release() 时内置计数器+1；

计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

#线程：信号量【锁】

from threading import Thread,current_thread,Semaphore
import time,random
sm=Semaphore(3)
def work():
    sm.acquire()
    print("target %s is running" %current_thread().getName())
    time.sleep(random.randint(1,3))
    sm.release()
    
if __name__=="__main__":
    for i in range(10):        
        t=Thread(target=work)    
        t.start()

来源：https://www.cnblogs.com/hapyygril/p/12590796.html

标签

线程阻塞