ReaderWriterLockSlim i async \ czekajĘ ...

Question

Mam pewne problemy z ReaderWriterLockSlim. Nie rozumiem, jak działa magia.

Mój kod:

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> 
    } 

Kiedy wprowadzić blokadę zapisu na < 1>, debugger widzę że _indexLock.IsWriteLockHeld jest true, ale kiedy kroki egzekucyjne do < 2> Widzę _indexLock.IsWriteLockHeld jest false i _indexLock.ExitWriteLock zgłasza wyjątek SynchronizationLockException z komunikatem "Blokada zapisu jest zwalniana bez trzymania". Co robię źle?

Answer 1

ReaderWriterLockSlim jest typem blokującym wątek, więc zwykle nie można go używać z async i await.

Należy użyć SemaphoreSlim z WaitAsync, lub (jeśli naprawdę potrzebujesz czytnika/lock pisarz), używać mojego AsyncReaderWriterLock from AsyncEx lub Stephen Toub's AsyncReaderWriterLock.

Answer 2

Można bezpiecznie emulować mechanizm blokujący czytnik/program rejestrujący za pomocą niezawodnego i lekkiego modelu SemaphoreSlim i zachować korzyści z async/await. Utwórz SemaphoreSlim, podając liczbę dostępnych blokad odpowiadającą liczbie procedur, które zablokują jednocześnie Twój zasób do czytania. Każdy z nich zażąda jednego zamka, jak zwykle. W celu rutynowego pisania upewnij się, że żąda wszystkich dostępnych blokad przed wykonaniem jego czynności.

W ten sposób twoja procedura pisania zawsze będzie działać samodzielnie, podczas gdy twoje procedury czytania mogą dzielić zasoby tylko między sobą.

Załóżmy na przykład, że masz dwie procedury czytania i jedną procedurę zapisu.

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) 
    } 
} 

Oczywiście ta metoda działa tylko wtedy, gdy wiesz wcześniej, ile procedur czytania można uruchomić w tym samym czasie. Wprawdzie zbyt wiele z nich sprawiłoby, że kod ten byłby brzydki.