同步线程
线程同步可以定义为一种方法，借助该方法我们可以确保两个或多个并发线程不会同时访问称为临界区的程序段。另一方面，我们知道临界区是程序中访问共享资源的部分。因此，我们可以说同步是确保两个或多个线程不会通过同时访问资源而相互交互的过程。下图显示了四个线程试图同时访问程序的关键部分。
为了更清楚地说明，假设有两个或多个线程尝试同时将对象添加到列表中。这一Behave无法成功结束，因为它要么会删除一个或所有对象，要么会完全破坏列表的状态。这里同步的作用是一次只有一个线程可以访问该列表。
线程同步问题
我们在实现并发编程或应用同步原语时可能会遇到问题。在本节中，我们将讨论两个主要问题。问题是 -
- 僵局
- 比赛条件
比赛条件
这是并发编程中的主要问题之一。对共享资源的并发访问可能会导致竞争状况。竞争条件可以定义为当两个或多个线程可以访问共享数据然后尝试同时更改其值时发生的情况。因此，变量的值可能是不可预测的，并且根据进程的上下文切换的时间而变化。
例子
考虑这个例子来理解竞争条件的概念 -
步骤 1 - 在这一步中，我们需要导入线程模块 -
import threading
步骤 2 - 现在，定义一个全局变量，例如 x，其值为 0 -
x = 0
步骤3 - 现在，我们需要定义increment_global()函数，它将在这个全局函数x中加1 -
def increment_global(): global x x += 1
步骤4 - 在这一步中，我们将定义taskofThread()函数，它将调用increment_global()函数指定的次数；对于我们的例子，它是 50000 次 -
def taskofThread():
for _ in range(50000):
increment_global()
步骤 5 - 现在，定义创建线程 t1 和 t2 的 main() 函数。两者都将在 start() 函数的帮助下启动，并在 join() 函数的帮助下等待完成工作。
def main(): global x x = 0 t1 = threading.Thread(target= taskofThread) t2 = threading.Thread(target= taskofThread) t1.start() t2.start() t1.join() t2.join()
步骤 6 - 现在，我们需要给出我们想要调用 main() 函数的迭代次数的范围。在这里，我们调用了 5 次。
if __name__ == "__main__":
for i in range(5):
main()
print("x = {1} after Iteration {0}".format(i,x))
在下面显示的输出中，我们可以看到竞争条件的影响，因为每次迭代后 x 的值预计为 100000。但是，该值存在很多变化。这是由于线程并发访问共享全局变量x造成的。
输出
x = 100000 after Iteration 0 x = 54034 after Iteration 1 x = 80230 after Iteration 2 x = 93602 after Iteration 3 x = 93289 after Iteration 4
使用锁处理竞争条件
正如我们在上面的程序中看到的竞争条件的影响，我们需要一个同步工具，它可以处理多个线程之间的竞争条件。在Python中，<threading>模块提供了Lock类来处理竞争条件。此外，Lock类提供了不同的方法，借助这些方法我们可以处理多个线程之间的竞争条件。这些方法描述如下 -
acquire() 方法
该方法用于获取锁，即阻塞锁。锁可以是阻塞的或非阻塞的，具体取决于以下 true 或 false 值 -
将值设置为 True - 如果使用 True（默认参数）调用 acquire() 方法，则线程执行将被阻止，直到锁解锁。
将值设置为 False - 如果使用 False（不是默认参数）调用 acquire() 方法，则线程执行不会被阻止，直到将其设置为 true，即直到它被锁定。
释放()方法
该方法用于释放锁。以下是与此方法相关的一些重要任务 -
如果锁被锁定，则release()方法将解锁它。它的作用是，如果多个线程被阻塞并等待锁解锁，则只允许一个线程继续执行。
如果锁已经解锁，它将引发ThreadError 。
现在，我们可以用锁类及其方法重写上面的程序来避免竞争条件。我们需要使用锁参数定义taskofThread()方法，然后需要使用acquire()和release()方法来阻塞和非阻塞锁以避免竞争条件。
例子
以下是 python 程序的示例，用于理解处理竞争条件的锁的概念 -
import threading
x = 0
def increment_global():
global x
x += 1
def taskofThread(lock):
for _ in range(50000):
lock.acquire()
increment_global()
lock.release()
def main():
global x
x = 0
lock = threading.Lock()
t1 = threading.Thread(target = taskofThread, args = (lock,))
t2 = threading.Thread(target = taskofThread, args = (lock,))
t1.start()
t2.start()
t1.join()
t2.join()
if __name__ == "__main__":
for i in range(5):
main()
print("x = {1} after Iteration {0}".format(i,x))
以下输出表明竞争条件的影响被忽略；因为每次迭代之后 x 的值现在为 100000，这符合该程序的预期。
输出
x = 100000 after Iteration 0 x = 100000 after Iteration 1 x = 100000 after Iteration 2 x = 100000 after Iteration 3 x = 100000 after Iteration 4
死锁 - 哲学家就餐问题
死锁是设计并发系统时可能面临的一个棘手问题。我们可以借助哲学家就餐问题来说明这个问题，如下 -
Edsger Dijkstra 最初介绍了哲学家就餐问题，这是并发系统最大问题之一（称为死锁）的著名例证之一。
在这个问题中，有五位著名的哲学家坐在圆桌旁，吃着碗里的食物。有五把叉子可供五位哲学家用来吃饭。然而，哲学家们决定同时使用两把叉子来吃食物。
现在，哲学家有两个主要条件。首先，每个哲学家都可以处于进食状态或思考状态，其次，他们必须首先获得两把叉子，即左叉和右叉。当五位哲学家同时拿起左边的叉子时，问题就出现了。现在他们都在等待合适的叉子被释放，但他们永远不会放弃他们的叉子，直到他们吃完食物，而合适的叉子永远不会可用。于是，餐桌上就会出现僵局。
并发系统中的死锁
现在，如果我们看到，同样的问题也可能出现在我们的并发系统中。上面例子中的分叉就是系统资源，每个哲学家都可以代表一个进程，该进程正在竞争获取资源。
用Python程序解决
这个问题的解决方案可以通过将哲学家分为两种类型来找到：贪婪的哲学家和慷慨的哲学家。主要是贪婪的哲学家会尝试拿起左边的叉子并等待它在那里。然后，他会等待合适的叉子出现，拿起它，吃，然后放下。另一方面，一个慷慨的哲学家会尝试拿起左边的叉子，如果它不在那里，他会等待一段时间后再次尝试。如果他们拿到了左边的叉子，那么他们就会尝试拿到右边的叉子。如果他们也能拿到正确的叉子，那么他们就会吃东西并释放两把叉子。然而，如果他们拿不到右边的叉子，那么他们就会释放左边的叉子。
例子
以下 Python 程序将帮助我们找到哲学家就餐问题的解决方案 -
import threading
import random
import time
class DiningPhilosopher(threading.Thread):
running = True
def __init__(self, xname, Leftfork, Rightfork):
threading.Thread.__init__(self)
self.name = xname
self.Leftfork = Leftfork
self.Rightfork = Rightfork
def run(self):
while(self.running):
time.sleep( random.uniform(3,13))
print ('%s is hungry.' % self.name)
self.dine()
def dine(self):
fork1, fork2 = self.Leftfork, self.Rightfork
while self.running:
fork1.acquire(True)
locked = fork2.acquire(False)
if locked: break
fork1.release()
print ('%s swaps forks' % self.name)
fork1, fork2 = fork2, fork1
else:
return
self.dining()
fork2.release()
fork1.release()
def dining(self):
print ('%s starts eating '% self.name)
time.sleep(random.uniform(1,10))
print ('%s finishes eating and now thinking.' % self.name)
def Dining_Philosophers():
forks = [threading.Lock() for n in range(5)]
philosopherNames = ('1st','2nd','3rd','4th', '5th')
philosophers= [DiningPhilosopher(philosopherNames[i], forks[i%5], forks[(i+1)%5]) \
for i in range(5)]
random.seed()
DiningPhilosopher.running = True
for p in philosophers: p.start()
time.sleep(30)
DiningPhilosopher.running = False
print (" It is finishing.")
Dining_Philosophers()
上面的程序使用了贪婪和慷慨哲学家的概念。该程序还使用了<threading>模块的Lock类的acquire()和release()方法。我们可以在以下输出中看到解决方案 -
输出
4th is hungry. 4th starts eating 1st is hungry. 1st starts eating 2nd is hungry. 5th is hungry. 3rd is hungry. 1st finishes eating and now thinking.3rd swaps forks 2nd starts eating 4th finishes eating and now thinking. 3rd swaps forks5th starts eating 5th finishes eating and now thinking. 4th is hungry. 4th starts eating 2nd finishes eating and now thinking. 3rd swaps forks 1st is hungry. 1st starts eating 4th finishes eating and now thinking. 3rd starts eating 5th is hungry. 5th swaps forks 1st finishes eating and now thinking. 5th starts eating 2nd is hungry. 2nd swaps forks 4th is hungry. 5th finishes eating and now thinking. 3rd finishes eating and now thinking. 2nd starts eating 4th starts eating It is finishing.