Notes d'étude (28): Réseau de programmation Python et la programmation concurrente - serrures récursives et blocages

Apprendre immédiatement: https://edu.csdn.net/course/play/24458/296445?utm_source=blogtoedu

1. (limitations de verrouillage ()) Deadlock

Pour obtenir le verrouillage () ne peut être obtenue (acquérir) une nouvelle fois doit être libéré afin d'obtenir: la connaissance

 

1) situation de blocage 1

#死锁情况1
from threading import Thread,Lock
import time
#设置了两把互斥锁
mutexA = Lock()
mutexB = Lock()

class mythread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        #首先线程1获得了A锁，再获得B锁，最后两个都释放，开始进行f2中的B锁，因为沉睡了0.1秒，足以让线程2获得f1中的A锁，接下来线程1的工作是沉睡结束后获得A锁，线程2准备获得B锁，一直处于等待锁的释放，因为线程1和线程2都是在等待彼此手中的那把锁，因此形成了死锁
        mutexA.acquire()
        print('%s获取到了A锁'%self.name)
        mutexB.acquire()
        print('%s获取到了B锁'%self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s获取到了B锁'%self.name)
        time.sleep(0.1)
        mutexA.acquire()
        print('%s获取到了A锁'%self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    #线程切换的速度非常快，因此可以看成是依次线程执行的
    for i in range(10):
        t = mythread()
        t.start()

 

2) situation de blocage 2

#死锁情况2
from threading import Thread,Lock
import time
#设置了两把互斥锁，且是同一把锁
mutexA = mutexB = Lock()


class mythread(Thread):
    def run(self):
        self.f1()

    def f1(self):
        #首先线程1获得了A锁，再获得B锁，最后两个都释放，开始进行f2中的B锁，因为沉睡了0.1秒，足以让线程2获得f1中的A锁，接下来线程1的工作是沉睡结束后获得A锁，线程2准备获得B锁，一直处于等待锁的释放，因为线程1和线程2都是在等待彼此手中的那把锁，因此形成了死锁
        mutexA.acquire()
        print('%s获取到了A锁'%self.name)
        mutexB.acquire()
        print('%s获取到了B锁'%self.name)
        mutexB.release()
        mutexA.release()

if __name__ == '__main__':
    #线程切换的速度非常快，因此可以看成是依次线程执行的
    for i in range(10):
        t = mythread()
        t.start()

 

2. verrouillage récursif (RLOCK): peut résoudre le problème de blocage

Connaissance Point: RLOCK (),

1) supporté par le même fil à plusieurs reprises été acquis (acquisition),

2) un compteur intégré, le même fil chaque fois, le compteur Acquire 1 , chaque sortie · une fois, Compteurs - 1 vers le comptoir à zéro , que le verrouillage récursif peut être accessible par d' autres fils (acquérir)

#递归锁情况
from threading import Thread,RLock
import time
#设置了两把互斥锁
mutexA = mutexB = RLock()


class mythread(Thread):
    def run(self):
        self.f1()
        self.f2()

    def f1(self):
        #首先线程1获得了A锁计数器+1为1，再获得B锁计数器+1为2，最后两个都释放计数器归零，锁可以被其他线程获取，因为线程速度快，所以线程1获取到了f2的B锁，计数器为1，因为沉睡了0.1秒且线程1的计数器为1，虽然足以让线程2去获得f1中的A锁，但是条件不允许啊（计数器不归零），接下来线程1的工作是沉睡结束后获得A锁，计数器为2，线程1释放两次后计数器为0，线程2立马获得锁，不一定是线程2获得
        mutexA.acquire()
        print('%s获取到了A锁'%self.name)
        mutexB.acquire()
        print('%s获取到了B锁'%self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('%s获取到了B锁'%self.name)
        time.sleep(0.1)
        mutexA.acquire()
        print('%s获取到了A锁'%self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    #线程切换的速度非常快，因此可以看成是依次线程执行的
    for i in range(10):
        t = mythread()
        t.start()

#运行结果
'''
"F:\software install\python3.6.4\python.exe" C:/Users/jinlin/Desktop/python_further_study/并发编程/死锁与递归锁（Rlock）.py
Thread-1获取到了A锁
Thread-1获取到了B锁
Thread-1获取到了B锁
Thread-1获取到了A锁
Thread-2获取到了A锁
Thread-2获取到了B锁
Thread-2获取到了B锁
Thread-2获取到了A锁
Thread-4获取到了A锁
Thread-4获取到了B锁
Thread-4获取到了B锁
Thread-4获取到了A锁
Thread-6获取到了A锁
Thread-6获取到了B锁
Thread-6获取到了B锁
Thread-6获取到了A锁
Thread-8获取到了A锁
Thread-8获取到了B锁
Thread-8获取到了B锁
Thread-8获取到了A锁
Thread-10获取到了A锁
Thread-10获取到了B锁
Thread-10获取到了B锁
Thread-10获取到了A锁
Thread-5获取到了A锁
Thread-5获取到了B锁
Thread-5获取到了B锁
Thread-5获取到了A锁
Thread-9获取到了A锁
Thread-9获取到了B锁
Thread-9获取到了B锁
Thread-9获取到了A锁
Thread-7获取到了A锁
Thread-7获取到了B锁
Thread-7获取到了B锁
Thread-7获取到了A锁
Thread-3获取到了A锁
Thread-3获取到了B锁
Thread-3获取到了B锁
Thread-3获取到了A锁

进程已结束,退出代码0
'''