sperren, die mehrere Leser in C# ermöglicht

Question

Ich habe den folgenden Code:

private static object _dbLock = new object(); 

public static void LoadData() 
{ 
    lock (_dbLock) 
    { 
     //Load data from the database 
    } 
} 

public static string ReadData(Guid key) 
{ 
    lock (_dbLock) 
    { 
     //Lookup key in data and return value 
    } 
} 

Ich möchte nicht, dass Menschen zu ermöglichen, die Daten zu lesen, während sie aus der Datenbank geladen wird ist, so habe ich eine lock in ReadData. Wenn jedoch mehrere Personen gleichzeitig ReadData anrufen, kann nur ein Anruf gleichzeitig ausgeführt werden.

Gibt es eine Möglichkeit, ich gleichzeitige Anrufe an ReadData zulassen kann, aber Leser blockieren, wenn LoadData ausgeführt wird?

Answer 1

Die Klassen ReaderWriterLock und unterstützen diesen Anwendungsfall. Verwenden Sie die "Slim" -Version, es sei denn, Sie benötigen Unterstützung vor Version 3.5.

private static ReaderWriterLockSlim _cacheLock = new ReaderWriterLockSlim(); 

public static void LoadData() 
{ 
    _cacheLock.EnterWriteLock(); 
    try 
    { 
     // Load data from the database 
    } 
    finally 
    { 
     _cacheLock.ExitWriteLock(); 
    } 
} 

public static string ReadData(Guid key) 
{ 
    _cacheLock.EnterReadLock(); 
    try 
    { 
     // Lookup key in data and return value 
    } 
    finally 
    { 
     _cacheLock.ExitReadLock(); 
    } 
} 

Answer 2

Versuchen die ManualResetEvent mit:

private static object _dbLock = new object(); 
private static ManualResetEvent _mrse = new ManualResetEvent(true); 

public static void LoadData() 
{ 

    lock (_dbLock) 
    { 
     _mrse.Reset(); 
     //Load data from the database 
     _mrse.Set(); 
    } 
} 

public static string ReadData(Guid key) 
{ 
    _mrse.Wait(); 
    //Lookup key in data and return value 
} 

Diese mehrere Leser ermöglicht die Datenlader zu warten seine Arbeit zu beenden und dann gleichzeitig gelesen. Wenn die Sammlung nicht Thread-sicher ist, müssen Sie ein anderes Sperrobjekt hinzufügen oder ein anderes Synchronisierungskonstrukt verwenden.