6.2多线程-互斥锁/死锁

互斥锁-解决资源竞争问题

方案1，两个线程其中一个上锁，执行完这个线程再执行下一个线程

#coding:utf-8
import threading
import time
 
# 创建一个全局变量
g_num = 0
 
def test1(num):
	global g_num
	# 上锁，如果之前没有上锁，那么此时上锁成功
	# 如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到锁被解开
	mutex.acquire()
	for i in range(num):
		g_num += 1
 
	# 解锁
	mutex.release()
	print('----in test1 g_num = %d' % g_num)
 
def test2(num):
	global g_num
	for i in range(num):
		g_num += 1
	print('----in test2 g_num = %d' % g_num)
 
# 创建一个互斥锁，默认没有上锁
mutex = threading.lock()
 
def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args = (1000000,))  #元组
	t2 = threading.Thead(target=test2, args = (1000000,))  #元组
 
	t1.start()
	t2.start()
 
	time.sleep(5)  # 等待上面两个线程执行完毕
	print('----in main Thread g_num = %d' % g_num)
 
if __name__ == '__main__':
	main()

方案2，每次循环计算都上锁，两个线程轮流执行

#coding:utf-8
import threading
import time
 
# 创建一个全局变量
g_num = 0
 
def test1(num):
	global g_num
	# 上锁，如果之前没有上锁，那么此时上锁成功
	# 如果上锁之前已经被上锁了，那么此时会堵塞在这里，直到锁被解开
	for i in range(num):
		mutex.acquire()
		g_num += 1
		mutex.release()
 
	print('----in test1 g_num = %d' % g_num)
 
def test2(num):
	global g_num
	for i in range(num):
		mutex.acquire()
		g_num += 1
		mutex.release()
	print('----in test2 g_num = %d' % g_num)
 
# 创建一个互斥锁，默认没有上锁
mutex = threading.lock()
 
def main():
	# target 指定将来这个线程去哪个函数执行代码
	# args 指定将来调用这个函数的时候传递什么数据过去
	t1 = threading.Thead(target=test1, args = (1000000,))  #元组
	t2 = threading.Thead(target=test2, args = (1000000,))  #元组
 
	t1.start()
	t2.start()
 
	time.sleep(5)  # 等待上面两个线程执行完毕
	print('----in main Thread g_num = %d' % g_num)
 
if __name__ == '__main__':
	main()

死锁

#coding:utf-8
import threading
import time

class MyThread1(threading.Thread):
	def run(self):
		# d对mutexA上锁
		mutexA.acquire()

		# muteA上锁后，延时1秒，等待另外那个线程，把mutexB上锁
		print(self.name + '___do1---start----')
		time.sleep(1)

		# 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
		mutexB.acquire()
		print(self.name + '___do1---end----')
		mutexB.release()

		# 对mutexA解锁
		mutexA.release()
class MyThread2(threading.Thread):
	def run(self):

		# 对mutexB上锁
		mutexB.acquire()

		# mutexB上锁后，延时1秒，等待那个线程 把muteA上锁
		print(self.name + '___do2---start----')
		time.sleep(1)

		# 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
		metexA.acquire()
		print(self.name + '___do2---end----')
		mutexA.release()

		# 对mutexB解锁
		mutexB.release()

mutexA = threading.lock()
mutexB = threading.lock()

if __name__ == '__main__':
	t1 = MyThread1()
	t2 = MyThread2()
	t1.start()
	t2.start()

解决死锁问题-1 程序设计时尽量避免（银行家算法）

解决死锁问题-2 添加超时时间