竞赛环境与死锁的区别

在编程术语中，死锁和围绕条件的竞赛之间的区别是什么？

50910 次浏览
小开

我假设你指的是“竞赛条件”而不是“围绕条件竞赛”(我听说过这个术语...)

基本上，死锁是这样一种情况: 线程 A 在持有资源 Y 上的锁时等待资源 X，而线程 B 在持有资源 X 上的锁时等待资源 Y。线程阻塞，等待对方释放它们的锁。

这个问题的解决方案(通常)是确保在所有线程中对 一样的顺序中的所有资源采用锁。例如，如果您总是锁定资源 X 之前资源 Y，那么我的示例永远不会导致死锁。

竞态条件是指您依赖于以特定顺序发生的特定事件序列，但是如果另一个线程在同一时间运行，则可能会出现混乱。例如，要将一个新节点插入到链表中，您需要修改链表头，通常如下所示:

newNode->next = listHead;
listHead = newNode;

但是如果两个线程同时执行这个操作，那么您可能会遇到这样的情况:

Thread A                       Thread B
newNode1->next = listHead
newNode2->next = listHead
listHead = newNode2
listHead = newNode1

如果发生这种情况，那么线程 B 对列表的修改将丢失，因为线程 A 会覆盖它。根据具体情况，情况可能更糟，但这是最基本的。

这个问题的解决方案通常是确保包含适当的锁定机制(例如，在您想要修改链表的任何时候删除一个锁，这样一次只有一个线程在修改它)。

小开

死锁是指两个(或更多)线程互相阻塞。通常这与试图获取共享资源的线程有关。例如，如果线程 T1和 T2需要同时获取资源 A 和 B 来完成它们的工作。如果 T1获取资源 A，那么 T2获取资源 B，那么 T1可能等待资源 B，而 T2等待资源 A。在这种情况下，两个线程都将无限期地等待另一个线程持有的资源。这些线程据说是死锁的。

竞争条件发生在两个线程以负(错误)方式交互时，这取决于它们不同指令执行的确切顺序。例如，如果一个线程设置了一个全局变量，那么第二个线程读取并修改该全局变量，而第一个线程读取该变量，则第一个线程可能会遇到 bug，因为该变量发生了意外更改。

小开
最佳答案

使用传统示例考虑竞态条件。假设你和一个朋友有同一个银行账户的 ATM 卡。现在假设账户里有100美元。想想当你试图取出10美元，而你的朋友同时取出50美元时会发生什么。

想想接下来会发生什么。ATM 机必须接收您的输入，读取您帐户中当前的内容，然后修改金额。注意，在编程术语中，赋值语句是一个多步骤的过程。

因此，标记您的交易 T1(您提取 $10)和 T2(您的朋友提取 $50)。下面左边的数字代表时间步骤。

       T1                        T2
----------------          ------------------------
1.    Read Acct ($100)
2.                              Read Acct ($100)
3.    Write New Amt ($90)
4.                              Write New Amt ($50)
5.                              End
6.    End

在两个事务完成后，使用这个时间线(如果不使用任何类型的锁定机制，这是可能的) ，账户里有50美元。这比应该的多了10美元(你的交易永远失败了，但你仍然有钱)。

这是一个所谓的竞态条件。你想要的事务是 可连载的，也就是说，无论你如何交错执行单个指令，最终的结果将与 一些串行调度完全相同(意味着你运行他们一个接一个没有交错)的相同的事务。同样，解决方案是引入锁定; 但是不正确的锁定可能导致死锁。

当共享资源发生冲突时，就会出现死锁，这有点像第二十二条军规。

   T1            T2
-------       --------
1.  Lock(x)
2.               Lock(y)
3.  Write x=1
4.               Write y=19
5.  Lock(y)
6.  Write y=x+1
7.               Lock(x)
8.               Write x=y+2
9.  Unlock(x)
10.              Unlock(x)
11. Unlock(y)
12.              Unlock(y)

您可以看到死锁发生在时间7，因为 T2试图获取 x上的锁，但是 T1已经持有 x上的锁，但是它正在等待 y的锁，而 y持有。

这么糟糕。您可以将此关系图转换为依赖关系图，您将看到存在一个循环。这里的问题是，x 和 y 是可以一起修改的资源。

防止使用多个锁对象(资源)时出现此类死锁问题的一种方法是引入排序。您可以看到，在前面的示例中，T1锁定 x，然后是 y，但是 T2锁定 y，然后是 x。如果这里的两个事务都遵循某种排序规则，即“ x应始终在 y之前锁定”，那么这个问题就不会发生。(您可以根据这个规则更改前面的示例，并且不会发生死锁)。

这些都是些琐碎的例子，我只是用了一些你们可能已经看到的例子，如果你们上过这方面的本科课程的话。实际上，解决死锁问题可能比这难得多，因为您往往有多个资源和多个事务相互作用。

希望这能有所帮助，像往常一样，使用维基百科作为 CS 概念的起点:

Http://en.wikipedia.org/wiki/deadlock

Http://en.wikipedia.org/wiki/race_condition

小开

僵局:

  1. 当 2个或更多线程彼此之间是 等待以便在无限长的时间内释放资源时，就会发生这种情况。
  2. 在这种情况下，线程处于阻塞状态并且不执行。

赛事/比赛条件:

  1. 当 2个或更多线程 并行运行最终给出的结果是错误的，如果所有操作按顺序执行，则结果不等效时，就会发生这种情况。
  2. 这里所有的线程都运行并执行这些操作。

在编码中，我们需要同时避免竞争和死锁条件。

小开

剩下的就是编程语言了如果你没有锁定共享资源并且被多个线程访问那么它被称为“竞争条件”第二种情况如果你锁定资源并且访问共享资源的顺序没有被正确定义那么线程可能会长时间等待资源使用那么这就是一个“死锁”的情况


提交答案