python 死锁 死锁的示例 with

死锁

1. 死锁: 死锁就是一直等待对方释放锁的情景
2. 死锁的结果会造成程序的停止响应, 不能再处理其他的任务了

死锁的示例

需求: 根据下标在列表中取值, 保证同一时刻只能有一个线程去取值

import threading
import time

#创建互斥锁
lock = threading.Lock()

# 根据下标去取值, 保证同一时刻只有一个线程去取值
def get_value(index):
	
	# 上锁
	lock.acquire()
	print(threading.current_thread())
	my_list = [3, 6, 8, 1]
	# 判断下标释放越界
	if index >= len(my_list):
		print("下标越界", index)
		return
	value = my_list[index]
	print("value", value)
	time.sleep(0.2)
	# 释放锁
	lock.release()


if __name__ == "__main__":
	# 模拟大量线程去执行操作
	for i in range(30):
		sub_thread = threading.Thread(target=get_value, args=(i,))
		sub_thread.start()

# 控制台输出
<Thread(Thread-1, started 10400)>
value 3
<Thread(Thread-2, started 568)>
value 6
<Thread(Thread-3, started 6360)>
value 8
<Thread(Thread-4, started 13328)>
value 1
<Thread(Thread-5, started 3012)>
下标越界 4


# 此刻程序还未结束

避免死锁

避免死锁就要在合适的地方释放锁

import threading
import time

# 创建互斥锁
lock = threading.Lock()

# 根据下标去取值, 保证在同一时刻只能有一个线程取值
def get_value(index):
	
	lock.acquire()
	print(threading.surrrent_thred())
	my_list = [3, 6, 8, 1]
	if index >= len(my_list):
		print("下标越界", index)
		# 当下标越界需要释放释放锁, 让后边的线程还可以取值
		lock.release()
		return
	value = my_list[index]
	print(value)
	time.sleep(0.2)
	lock.release()


if __name__ == "__main__":
	# 模拟大量线程去执行取值操作
	for i in range(30):
		sub_thread = threading.Thread(target=get_value, args=(i,))
		sub_thread.start()

		
#  控制台输出 <没有产生死锁>
<Thread(Thread-1, started 14704)>
3
<Thread(Thread-2, started 11788)>
6
<Thread(Thread-3, started 1220)>
8
<Thread(Thread-4, started 15180)>
1
<Thread(Thread-5, started 11204)>
下标越界 4
<Thread(Thread-6, started 12608)>
...
<Thread(Thread-29, started 9496)>
下标越界 28
<Thread(Thread-30, started 12456)>
下标越界 29

个人见解,仅供参考
刚才在写避免死锁的程序时, 突然奇想想用 with 试试, 试完之后发现 with 能巧妙地避开这个死锁的问题.然后大胆想象了一下, with 是不是能避免死锁, 就百度找了下文章. 发现 python中确实可以用 with 避免死锁

import threading
import time

# 创建互斥锁
lock = threading.Lock()

# 根据下标去取值, 保证同一时刻只能有一个线程去取值


def get_value(index):
	# with 自己上锁, 并自己释放锁
	with lock:
		print(threading.current_thread())
		my_list = [3, 6, 8, 1]
		if index >= len(my_list):
			print("下标越界", index)
			return
		value = my_list[index]
		print(value)
		time.sleep(0.2)


if __name__ == "__main__":
	# 模拟大量线程去执行取值操作
	for i in range(30):
		sub_thread = threading.Thread(target=get_value, args=(i,))
		sub_thread.start()

小结

1. 使用互斥锁的时候需要注意死锁的问题, 要在合适的地方注意释放锁
2. 死锁一旦产生就会造成应用程序的停止响应, 应用程序无法再继续往下执行了
3. with 可以避免上边的问题, 个人见解