Python死锁

死锁

不合理的同步方式，将会造成死锁，死锁有大致如下两种

递归死锁

当一把锁在一个进程下重复使用而并未及时释放时，会造成死锁

自己持有锁时，二次加锁，这就是重复加锁，会导致死锁

• 实现递归死锁

from multiprocessing import Process,Lock,RLock

def func(lock):
    print('开启进程')
    with lock:# 加锁
        print('获取到lock锁')
        with lock:
		    print('再次获取lock锁') # 重复加锁

def main():
    lock = Lock()
    p1 = Process(target=func,args=(lock,))
    p2 = Process(target=func,args=(lock,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
if __name__ == '__main__':
	main()

• 解决递归死锁，通过可重入锁RLock；重用锁在单独环境下多次使用，会在内部维护当前一个使用次数，可以在当前环境多次使用

但是对应的，每次acquire被记录了次数，也只有对应次数release才可以释放锁，否则其他进程、线程依旧无法获锁，这个锁只是给定了多次重复持锁的办法

from multiprocessing import Process,Lock,RLock

def func(lock):
    print('开启进程')
    if lock.acquire(1):
        print('获取到lock锁')
        lock.acquire()
        lock.release()
        lock.release()

def main():
    lock = RLock()
    p1 = Process(target=func,args=(lock,))
    p2 = Process(target=func,args=(lock,))
    p1.start()
    p1.join()
    p2.start()
    p2.join()
if __name__ == '__main__':
	main()

以上这段代码，可以持有两次锁，对应释放两次锁，代码正常执行

争夺锁

当两个以上进程获取了对方接下来所需要的锁，从而进入等待资源状态，也会造成死锁

• 比如

from multiprocessing import Process,Lock
import time
import sys
def a(l_a,l_b):
    with l_a:
        print('持有a锁')
        sys.stdout.flush()
        time.sleep(1) #等待b进程获取b锁，实现死锁
        with l_b:
          	print('持有b锁')
def b(l_a,l_b):
    with l_b:
        print('持有b锁')
        with l_a:
          	print('持有a锁')
def main():
    l_a = Lock()
    l_b = Lock()
    p1 = Process(target=a,args=(l_a,l_b))
    p2 = Process(target=b,args=(l_a,l_b))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

if __name__ == '__main__':
	main()

• 注意：由于竞争锁的进程之间不构成可以程过结束运行的程序，所以缓冲区不会被Python自动刷新；一般缓冲刷新的动作在程序结束或手动刷新时，所以需要我们在进程中手动通过sys.stdout.flush()进行输出缓冲区的刷新

解决争夺锁的办法是程序员在编写代码的时候不要脑子犯抽，要明确每一把锁的意义和加持顺序

进程池

当我们使用传统的Process来创建进程时，小规模进程量还OK，但是一旦需要成百上千的进程，可以通过构建进程池解决；池的真正的并发数量由CPU核数决定

在任务开启时，每个任务会到进程池中获取对应进程资源

如果没有可用进程，那么任务会被挂起等待，直到有新的进程资源去接管处理他

from multiprocessing import Pool
p = Pool(3,maxtasksperchild)
'''
maxtasksperchild: 指明一个进程同时可以执行的最大工作数
'''
# 创建一定个数的进程池
p.apply(func, args) 
# 阻塞方式，调用函数及传入参数，下个进程阻塞直到上个进程结束
p.apply_async(func, args) 
# 非阻塞方式，调用函数及传入参数，并发完成任务
p.close() 
# 关闭进程池不在接收新的任务进入
p.join() 
# 父进程等待全部子进程结束，必须在close函数之后
p.terminat() 
# 直接关闭进程池并终止所有进程任务

• 获取进程池返回值

res = p.apply()		# 阻塞多进程执行函数返回值 即为任务函数的返回值
res = p.apply_async() # 非阻塞多进程执行函数返回值是一个结果对象
'''
	- res.get() 即可获得任务函数的返回值
'''
res = p.map(func, range(10)) # 进程池中的map函数类似普通map函数，将一个序列中的每个值作为参数传递到任务函数中，返回值也将是一个序列对象，用来保存每个进程任务返回的结果，该函数为阻塞直到结果出现
res = p.map_async() # 执行之后，为一个抽象任务队列，只有真正使用 res.get()获取值时，任务进程才会执行，并且为非阻塞方式运行

• 进程池代码示例

from multiprocessing import Pool,current_process
import time
import sys
def work(num):
    time.sleep(0.5)
    print('当前进程是:',current_process().name,':',num)
    return num

def main():
    p = Pool(3)
    print("开启进程")
    res = []
    for var in range(10):
      	res.append(p.apply(func=work,args=(var,)))
      	# res.append(p.apply_async(func=work,args=(var,)))
    p.close() #关闭进程池
    p.join()
    print(res) # apply 
    # for var in res: # apply_async
    # 	print(var.get(),end=' ')
    print('\nover')
	
if __name__ == '__main__':
	main()

进程池加锁

本身的多进程apply函数已经是阻塞模式，所以加锁意义不大

当遇到apply_async函数时，由于此时为真正的异步，我们可能需要在进程池内进行锁操作

• 可以使用如下进行同步管理

from multiprocessing import Manager
lock  = Manager().Lock()
semphore = Manager().Semaphore()