Jak mogę wdrożyć własną blokadę TaS w języku C#?

Question

Tak więc dla zadania musimy mieć możliwość skorzystania z C# -Lock lub użyć samouruchomionego TaS-Lock. To, co przeczytałem na temat TaS-Locks, polega na tym, że używa 1 kroku atomowego do czytania i pisania wartości. Zasugerowano nam, że używamy klasy Interlocked w C# do tego.

Jak dotąd jest to, co mam, ale wydaje się, aby doprowadzić do niespójnych odpowiedzi:

public interface Lock 
{ 
    void Lock(); 
    void Unlock(); 
} 

public class C_Sharp_Lock : Lock 
{ 
    readonly Object myLock = new object(); 

    public void Lock() 
    { 
     Monitor.Enter(myLock); 
    } 

    public void Unlock() 
    { 
     Monitor.Exit(myLock); 
    } 
} 

public class Tas_Lock : Lock 
{ 
    int L = 0; 

    public void Lock() 
    { 
     while (0 == Interlocked.Exchange(ref L, 1)) { }; 
    } 

    public void Unlock() 
    { 
     Interlocked.Exchange(ref L, 0); 
    } 
} 

Czy ktoś wie, co robię źle tutaj?

Edit: W odpowiedzi na Kevin:

Zmieniłem ją na następujące kwestie:

public class Tas_Lock : Lock 
{ 
    int L = 0; 

    public void Lock() 
    { 
     while (0 == Interlocked.CompareExchange(ref L, 1, 0)) { }; 
    } 

    public void Unlock() 
    { 
     Interlocked.Exchange(ref L, 0); 
    } 
} 

Jednak to wciąż powraca niespójnych wyników.

Edit # 2: Zmiany w C# blokady:

public class C_Sharp_Lock : Lock 
{ 
    readonly Object myLock = new object(); 
    bool lockTaken = false; 

    public void Lock() 
    { 
     Monitor.Enter(myLock, ref lockTaken); 
    } 

    public void Unlock() 
    { 
     if (lockTaken) 
      Monitor.Exit(myLock); 
    } 
} 

Answer 1

Ty nieporozumienie drogę Interlocked.CompareExchange prace. Zamiana wartości atomatycznie, jeśli wcześniej była równa podanemu porównaniu, i zwraca poprzednią wartość.

W skrócie, Interlocked.CompareExchange(ref L, 1, 0) będzie:

• Sprawdź, czy L jest równe 0
• Jeżeli L jest równe 0, to zestaw L 1 i powrócić do poprzedniej wartości (0)
• Jeśli L nie jest równe 0 (a więc jest równa 1), a następnie powróci do poprzedniej wartości (1)

Stamtąd, co należy zrobić, to pętla ażInterlocked.CompareExchange zwraca 0 (co oznacza, że ​​została uzyskana blokada). W kodzie, czekasz whileInterlocked.CompareExchange zwraca 0.

Kod Poprawiono:

public class Tas_Lock 
{ 
    int L = 0; 

    public void Lock() 
    { 
     while (0 != Interlocked.CompareExchange(ref L, 1, 0)) { } 
    } 

    public void Unlock() 
    { 
     Interlocked.Exchange(ref L, 0); 
    } 
} 

Dwie rzeczy do uwaga:

• Interlocked.Exchange w Unlock mogłyby zostać zastąpione przez szybciej Volatile.Write (lub nawet, choć można argumentować, prosty zapis)
• Jeśli nie było to zadanie, można użyć wbudowanego -w klasie SpinLock, która już robi wszystkie te rzeczy w zoptymalizowany sposób