Unterschied zwischen racearound-Bedingung und Deadlock

Denke, einer race-condition mit der herkömmlichen Beispiel. Sagen Sie, dass Sie und ein Freund haben eine ATM Karte für das gleiche Konto. Nehmen wir nun an, das Konto über $100. Überlegen Sie, was passiert, wenn Sie versuchen, Rücktritt $10 und Ihr Freund versucht, Sie zurückzuziehen $50 an genau der gleichen Zeit.

Darüber nachdenken, was zu geschehen hat. Die ATM Maschine muss nehmen Sie Ihre Eingaben, Lesen Sie, was derzeit in Ihr Konto ein, und ändern Sie dann die Menge. Beachten Sie, dass in der Programmierung Begriffe, eine abtretungserklärung ist ein multi-Schritt-Prozess.

So, Etikett beiden Transaktionen T1 (Sie zurücktreten $10), und T2 (dein Freund zieht sich zurück $50). Nun, die zahlen unten auf der linken Seite repräsentieren die Zeit, die Schritte.

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

Nachdem beide Transaktionen abzuschließen, mit dieser timeline, was möglich ist, wenn Sie nicht verwenden, jede Art von Verriegelungsmechanismus, der account hat $50. Dies ist $10 mehr als es sein sollte (Ihrer Transaktion ist für immer verloren, aber Sie haben noch das Geld).

Dies ist eine sogenannte race-condition. Was Sie wollen, ist für die Transaktion serializabledas ist in egal, wie Sie das verschachteln der einzelnen Anweisung Hinrichtungen, das Endergebnis ist genau das gleiche wie einige seriellen schedule (Bedeutung, die Sie ausführen, eine nach der anderen ohne interleaving) von der gleichen Transaktionen. Die Lösung, wieder, ist die Einführung von sperren; jedoch falsche-Verriegelung kann dazu führen, dead lock.

Deadlock tritt auf, wenn es einen Konflikt der eine freigegebene Ressource. Es ist ein bisschen wie ein Catch-22.

   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)

Können Sie sehen, dass ein deadlock Auftritt bei mal 7, weil T2 versucht, eine Sperre erwerben, die auf x aber T1 hat bereits den lock auf x aber es ist das warten auf eine Sperre für ydas T2 hält.

So schlimm. Sie können diese Diagramme in ein abhängigkeitsdiagramm und Sie werden sehen, dass es einen Zyklus. Das problem hier ist, dass x und y sind Ressourcen, die geändert werden können, zusammen.

Einen Weg, um zu verhindern, dass diese Art von deadlock-problem mit mehrere lock-Objekte (Ressourcen), ist die Einführung einer Bestellung. Sie sehen, im vorherigen Beispiel, T1 gesperrt x und dann y aber T2 gesperrt y und dann x. Wenn beide Transaktionen eingehalten hier einige Bestell-Regel, die sagt, " x muss stets abgeschlossen sein, bevor y" dann wird dieses problem nicht auftreten. (Sie können ändern, das vorherigen Beispiel mit dieser Regel im Hinterkopf, und sehen keinen deadlock).

Diese Beispiele sind trivial und wirklich, ich habe nur die Beispiele, die Sie vielleicht schon gesehen haben, wenn Sie getroffen haben, jede Art von undergrad-Kurs auf diese. In der Realität, der Lösung des deadlock-Probleme können sehr viel schwieriger sein als diese, weil Sie dazu neigen zu haben mehr als ein paar Ressourcen und ein paar Transaktionen interagieren.

Hoffe, das hilft ein wenig. Wie immer, verwenden Wikipedia als Ausgangspunkt für die CS-Konzepte:

http://en.wikipedia.org/wiki/Deadlock

http://en.wikipedia.org/wiki/Race_condition

InformationsquelleAutor der Antwort BobbyShaftoe

Ich nehme an, du meinst "race conditions" und nicht "race around conditions" (ich habe gehört, der Begriff...)

Grundsätzlich ein dead lock ist ein Zustand, wo Ein thread wartet auf resource X, während eine Sperre auf der Ressource Y, und thread B wartet darauf, für Ressource Y, während eine Sperre auf der Ressource X. Die threads blockieren, aufeinander zu warten, um Ihre sperren freigeben.

Die Lösung für dieses problem ist (in der Regel), um sicherzustellen, dass Sie sperren auf alle Ressourcen in der gleichen Reihenfolge in allen threads. Zum Beispiel, wenn Sie immer sperren Ressource X vor Ressource Y, dann ist mein Beispiel, kann nie führen in eine Sackgasse.

Einer race-condition ist etwas, wo Sie sich darauf verlassen, dass eine bestimmte Sequenz von Ereignissen in einer bestimmten Reihenfolge, aber das kann verhunzt werden, wenn ein anderer thread zur gleichen Zeit ausgeführt. Zum Beispiel, um einen neuen Knoten einfügen in einer verknüpften Liste, müssen Sie zum ändern der Liste Kopf, in der Regel so etwas wie:

newNode->next = listHead;
listHead = newNode;

Aber wenn zwei threads tun, dass zur gleichen Zeit, dann könnten Sie in einer situation, wo Sie laufen, etwa so:

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

Wenn das geschieht, dann Thread B änderung der Liste verloren, da Thread A würde überschrieben haben. Es kann noch schlimmer werden, abhängig von der genauen situation, aber das sind die Grundlagen.

Die Lösung für dieses problem ist in der Regel, um sicherzustellen, dass die richtigen locking-Mechanismen (zum Beispiel, nehmen Sie eine Sperre jedes mal, wenn Sie wollen, ändern Sie die verknüpfte Liste, so dass nur ein thread ist, ändern Sie es zu einem Zeitpunkt).

InformationsquelleAutor der Antwort Dean Harding