进程(线程)锁、信号量、递归锁

进程锁(线程锁同进程锁相同，将模块以及创建进程改为线程即可)

import multiprocessing  #导入multiprocessing模块

def func(lock):
    #lock.acquire  #创建锁
    with lock:  #使用with lock：pass 语句，可以替代创建和释放锁的过程
        pass
    #lock.release  #释放锁

if __name__ == '__main__':
    lock = multiprocessing.Lock()
    for num in range(10): #循环创建
        #主要参数：target为执行函数 lock作为参数传入函数
        p = multiprocessing.Process(target=func,args=(lock,))
        p.start()  #进程开始

进程信号量(线程信号量同进程信号量相同，将模块以及创建进程改为线程即可)

import multiprocessing

def func(lock):
    with lock:
        pass

if __name__ == '__main__':
    se = multiprocessing.Semaphore(5)  #设置进程信号量
    for num in range(10):
        #主要参数：target为执行函数 se作为参数传入函数
        p = multiprocessing.Process(target=func,args=(se,))
        p.start()

递归锁

理解：这里循环创建的10个线程，都需要资源1和资源2，当我们某个线程抢占到资源1，而另一个线程抢占到资源2，就会形成死锁状态，引入递归锁(解决办法之一)

• 创建递归锁，当func1中的资源1被某个线程抢占，递归锁计数加一，而func2中的递归锁计数也加一，此时其他线程不在对资源2进行抢占，待func1中执行完毕，将锁释放完毕，递归锁计数为0，所有线程开始对资源进行抢占，直到递归锁计数加一
• 此时func1中和func2中都创建有递归锁，他们抢占的资源中含有共享资源，所以我们需要将func1和func2中都创建递归锁，若此时有func3，并不需要资源1和资源2，那么则无需在func3中创建递归锁，只需在抢占共享资源时设置递归锁

import threading

class MyThread(threading.Thread):

    def func1(self):
        rlock.acquire()
        代码块(含有共同需要的资源1)
        rlock.acquire()
        代码块(含有共同需要的资源2)
        rlock.release()
        rlock.release()

    def func2(self):
        rlock.acquire()
        代码块(含有共同需要的资源2)
        rlock.acquire()
        代码块(含有共同需要的资源1)
        rlock.release()
        rlock.release()

    def run(self):
        self.func1()
        self.func2()


if __name__ == '__main__':
    rlock = threading.RLock()  #创建递归锁
    for x in range(10):  #循环创建10个线程
        t = MyThread()
        t.start()