Python - 线程死锁

死锁可以描述为并发失败模式。在程序中，一个或多个线程等待从未发生的条件的情况。因此，线程无法继续，程序卡住或冻结，必须手动终止。

在并发程序中，死锁情况可能以多种方式出现。死锁从来都不是有意开发的，相反，它们实际上是代码中的副作用或 bug。

下面列出了线程死锁的常见原因 -

• 尝试两次获取同一互斥锁的线程。
• 彼此等待的线程（例如 A 等待 B，B 等待 A）。
• 当线程无法释放 lock、semaphore、condition、event 等资源时。
• 以不同顺序获取互斥锁的线程（例如，无法执行锁排序）。

如何避免 Python 线程中的死锁

当多线程应用程序中的多个线程尝试访问同一资源时，例如对同一文件执行读/写操作，可能会导致数据不一致。因此，使用锁定机制同步对资源的并发访问非常重要。

Python threading 模块提供了一种易于实现的锁定机制来同步线程。您可以通过调用 Lock（） 类来创建新的锁对象，该类将锁初始化为解锁状态。

带有 Lock 对象的锁定机构

Lock 类的对象有两种可能的状态 - 锁定或解锁，最初在首次创建时处于解锁状态。锁不属于任何特定线程。

Lock 类定义 acquire（） 和 release（） 方法。

acquire（） 方法

Lock 类的 acquire（） 方法将锁的状态从 unlocked 更改为 locked。除非可选的 blocking 参数设置为 True，否则它会立即返回，在这种情况下，它会等待直到获取锁。

这是此方法的语法 -

 Lock.acquire(blocking, timeout)

哪里

• blocking − 如果设置为 False，则表示不阻止。如果阻止设置为 True 的调用会阻止，则立即返回 False;否则，将锁设置为 locked 并返回 True。
• timeout - 指定获取锁的超时期限。

如果成功获取锁，则此方法的返回值为 True;否则为 False。

release（） 方法

当状态为 locked 时，另一个线程中的此方法会将其更改为 unlocked。这可以从任何线程调用，而不仅仅是从已获取锁的线程调用

以下是 release（） 方法的语法 -

 Lock.release()

release（） 方法只能在 locked 状态下调用。如果尝试释放未锁定的锁，将引发 RuntimeError。

锁定后，将其重置为解锁状态，然后返回。如果任何其他线程被阻塞，等待锁解锁，则只允许其中一个线程继续。此方法没有返回值。

在下面的程序中，两个线程尝试调用 synchronized（） 方法。其中一个服务器获取锁并获得访问权限，而另一个服务器等待。当第一个线程的 run（） 方法完成时，锁将被释放，并且 synchronized 方法可用于第二个线程。

当两个线程都加入时，程序结束。

from threading import Thread, Lock
import time

lock=Lock()
threads=[]

class myThread(Thread):
	 	def __init__(self,name):
	 	 	 Thread.__init__(self)
	 	 	 self.name=name
	 	def run(self):
	 	 	 lock.acquire()
	 	 	 synchronized(self.name)
	 	 	 lock.release()

def synchronized(threadName):
	 	print ("{} has acquired lock and is running synchronized method".format(threadName))
	 	counter=5
	 	while counter:
	 	 	 print ('**', end='')
	 	 	 time.sleep(2)
	 	 	 counter=counter-1
	 	print('\nlock released for', threadName)

t1=myThread('Thread1')
t2=myThread('Thread2')

t1.start()
threads.append(t1)

t2.start()
threads.append(t2)

for t in threads:
	 	t.join()
print ("end of main thread")

它将产生以下输出 -

用于同步的信号量对象

除了锁之外，Python 线程模块还支持信号量，这提供了另一种同步技术。它是著名计算机科学家 Edsger W. Dijkstra 发明的最古老的同步技术之一。

信号量的基本概念是使用内部计数器，该计数器由每个 acquire（） 调用递减，并由每个 release（） 调用递增。计数器永远不会低于零;当 acquire（） 发现它为零时，它会阻塞，直到其他线程调用 release（）。

threading 模块中的 Semaphore 类定义了 acquire（） 和 release（） 方法。

acquire（） 方法

如果内部计数器在输入时大于零，则将其减量 1 并立即返回 True。

如果内部计数器在输入时为零，则阻塞直到被调用 release（） 唤醒。唤醒 （且计数器大于 0） 后，将计数器递减 1 并返回 True。每次调用 release（） 都会唤醒一个线程。线程唤醒的顺序是任意的。

如果 blocking 参数设置为 False，则不阻止。如果没有参数的调用会阻塞，则立即返回 False;否则，执行与不带参数调用时相同的操作，并返回 True。

release（） 方法

释放信号量，将内部计数器增加 1。当它在输入时为零，并且其他线程正在等待它再次大于零时，唤醒其中的 n 个线程。

例

此示例演示如何在 Python 中使用 Semaphore 对象来控制对多个线程之间共享资源的访问，以避免 Python 多线程程序中的死锁。

from threading import *
import time

# creating thread instance where count = 3
lock = Semaphore(4)

# creating instance
def synchronized(name):
	 	
	 	# calling acquire method
	 	lock.acquire()

	 	for n in range(3):
	 	 	 print('Hello! ', end = '')
	 	 	 time.sleep(1)
	 	 	 print( name)

	 	 	 # calling release method
	 	 	 lock.release()

# creating multiple thread
thread_1 = Thread(target = synchronized , args = ('Thread 1',))
thread_2 = Thread(target = synchronized , args = ('Thread 2',))
thread_3 = Thread(target = synchronized , args = ('Thread 3',))

# calling the threads
thread_1.start()
thread_2.start()
thread_3.start()

它将产生以下输出 -