ReaderWriterLockSlim und async \ erwarten

Question

ich mit ReaderWriterLockSlim einige Probleme haben. Ich kann nicht verstehen, wie es funktioniert.

Mein Code:

private async Task LoadIndex() 
    { 
     if (!File.Exists(FileName + ".index.txt")) 
     { 
      return; 
     } 
     _indexLock.EnterWriteLock();// <1> 
     _index.Clear(); 
     using (TextReader index = File.OpenText(FileName + ".index.txt")) 
     { 
      string s; 
      while (null != (s = await index.ReadLineAsync())) 
      { 
       var ss = s.Split(':'); 
       _index.Add(ss[0], Convert.ToInt64(ss[1])); 
      } 
     } 
     _indexLock.ExitWriteLock();<2> 
    } 

Wenn ich Schreibsperre auf < 1>, in Debugger eingeben kann ich sehen, dass _indexLock.IsWriteLockHeldtrue ist, aber wenn die Ausführung Schritte < 2> Ich sehe _indexLock.IsWriteLockHeldfalse und _indexLock.ExitWriteLock löst eine Ausnahme SynchronizationLockException mit der Meldung "Die Schreibsperre wird freigegeben, ohne gehalten zu werden". Was mache ich falsch?

Answer 1

ReaderWriterLockSlim ist ein Thread-affine Lock-Typ, so kann es normalerweise nicht mit async und await verwendet werden.

Sie entweder SemaphoreSlim mit WaitAsync verwenden sollten, oder (wenn Sie wirklich einen Leser/Schreiber-Sperre müssen), verwenden Sie meine AsyncReaderWriterLock from AsyncEx oder Stephen Toub's AsyncReaderWriterLock.

Answer 2

Mit dem zuverlässigen und leichten SemaphoreSlim können Sie einen Lese-/Schreibgerät-Verriegelungsmechanismus sicher emulieren und die Vorteile von async/await beibehalten. Erstellen Sie SemaphoreSlim und geben Sie die Anzahl der verfügbaren Sperren an, die der Anzahl der Routinen entspricht, die Ihre Ressource gleichzeitig lesen. Jeder wird wie üblich eine Sperre anfordern. Stellen Sie für Ihre Schreibroutine sicher, dass sie alle verfügbaren Sperren anfordert, bevor Sie ihre Aufgabe ausführen.

Auf diese Weise wird Ihr Schreiben Routine immer alleine laufen, während die Leseroutinen die Ressource zwischen sich nur gemeinsam nutzen könnten.

Angenommen, Sie haben 2 Lese- und 1 Schreibroutine.

SemaphoreSlim semaphore = new SemaphoreSlim(2); 

async void Reader1() 
{ 
    await semaphore.WaitAsync(); 
    try 
    { 
     // ... reading stuff ... 
    } 
    finally 
    { 
     semaphore.Release(); 
    } 
} 

async void Reader2() 
{ 
    await semaphore.WaitAsync(); 
    try 
    { 
     // ... reading other stuff ... 
    } 
    finally 
    { 
     semaphore.Release(); 
    } 
} 

async void ExclusiveWriter() 
{ 
    // the exclusive writer must request all locks 
    // to make sure the readers don't have any of them 
    // (I wish we could specify the number of locks 
    // instead of spamming multiple calls!) 
    await semaphore.WaitAsync(); 
    await semaphore.WaitAsync(); 
    try 
    { 
     // ... writing stuff ... 
    } 
    finally 
    { 
     // release all locks here 
     semaphore.Release(2); 
     // (oh here we don't need multiple calls, how about that) 
    } 
} 

Offensichtlich funktioniert diese Methode nur, wenn Sie vorher wissen, wie viele Lesefunktionen Sie gleichzeitig ausführen können. Zugegeben, zu viel von ihnen würden diesen Code sehr hässlich machen.