Fetch und Beschreibung falsch hinzufügen?

Question

Ich versuche zu verstehen, wie fetch und add (atomare Operation) in einer Lock-Implementierung verwendet werden.

Ich stieß auf diesen Artikel in Wikipedia, fand ich es in mindestens einem anderen Ort dupliziert. Die Implementierung macht keinen Sinn und sieht für mich einen Bug oder mehr aus. Natürlich könnte ich einen subtilen Punkt vermissen und nicht wirklich verstehen, was beschrieben wird.

Von https://en.wikipedia.org/wiki/Fetch-and-add

---

<<atomic>> 
    function FetchAndAdd(address location, int inc) { 
     int value := *location 
     *location := value + inc 
     return value 
    } 

    record locktype { 
     int ticketnumber 
     int turn 
    } 
    procedure LockInit(locktype* lock) { 
     lock.ticketnumber := 0 
     lock.turn := 0 
    } 
    procedure Lock(locktype* lock) { 
     int myturn := FetchAndIncrement(&lock.ticketnumber) //must be atomic, since many threads might ask for a lock at the same time 
     while lock.turn ≠ myturn 
      skip // spin until lock is acquired 
    } 
    procedure UnLock(locktype* lock) { 
     FetchAndIncrement(&lock.turn) //this need not be atomic, since only the possessor of the lock will execute this 
    } 

---

Artikel Laut sie zuerst lockinit tun. FetchAndIncrement ruft FetchAndAdd mit inc auf 1.

Wenn dies keinen Fehler enthält, verstehe ich nicht, wie es möglicherweise funktionieren könnte.

Der erste Thread den Zugriff auf sie es bekommen:

lock.ticketnumber = 1 lock.turn = 0.

von 5 bis die Sperre sagen Lassen Sie mehr Zugriffe passieren, bevor es freigegeben wird.

lock.ticketnumber = 6 lock.turn = 0

erste Thread die Sperre freigibt.

lock.ticketnumber = 6 lock.turn = 1

Next Faden kommt und der Status

lock.ticketnumber = 7 lock.turn = 1

Und die zurück wäre Wert: myturn = 6 (Lock.Tickennummer vor der Faa).

In diesem Fall der:

während lock.turn ≠ myturn

kann niemals wahr sein.

Gibt es in dieser Illustration einen Fehler oder fehlt mir etwas?

Wenn es einen Bug in dieser Implementierung gibt, was würde es reparieren?

Thanx

Julian

Answer 1

Dang es, ich habe es jetzt zu sehen. Ich fand es in Bezug auf eine allgemeine Beschreibung des Algorithmus und dann sah ich es genauer an.

Wenn ein Thread Lock aufruft, dreht es sich um den Wert, den es zurückbekommen hat. Aus irgendeinem Grund dachte ich, es würde diese Funktion immer wieder aufrufen.

Wenn es sich dreht, wartet es, bis ein anderer Thread inkrementiert wird und schließlich die Nummer von myturn wird.

Entschuldigung für die Verschwendung Ihrer Zeit.

https://en.wikipedia.org/wiki/Ticket_lock