Cross-Prozess Schreib-Lese-Synchronisierungsgrund in .NET?

Question

Gibt es einen Lese- / Schreib-Verriegelungsmechanismus, dass die Arbeiten über Prozesse (ähnlich wie Mutex, aber lesen / schreiben, anstatt exklusive Verriegelung)? Ich mag gleichzeitigen Lesezugriff, aber exklusiven Schreibzugriff ermöglichen.

Answer 1

Nein. Wie Richard oben erwähnt, ist es nicht so aus dem Box-Mechanismus in .NET. Dies ist, wie es zu implementieren ein Mutex und Semaphore verwendet wird.

Methode # 1 ist in der http://www.joecheng.com/ Blog / Einträge / Writinganinter-processRea.html , zitiert zu werden:

// create or open global mutex
GlobalMutex mutex = new GlobalMutex("IdOfProtectedResource.Mutex");
// create or open global semaphore
int MoreThanMaxNumberOfReadersEver = 100;

GlobalSemaphore semaphore = new GlobalSemaphore("IdOfProtectedResource.Semaphore", MoreThanMaxNumberOfReadersEver);

public void AcquireReadLock()
{
  mutex.Acquire();
  semaphore.Acquire();
  mutex.Release();
}

public void ReleaseReadLock()
{
  semaphore.Release();
}

public void AcquireWriteLock()
{
  mutex.Acquire();
  for (int i = 0; i < MoreThanMaxNumberOfReadersEver; i++)
    semaphore.Acquire(); // drain out all readers-in-progress
  mutex.Release();
}

public void ReleaseWriteLock()
{
  for (int i = 0; i < MoreThanMaxNumberOfReadersEver; i++)
    semaphore.Release();
}

Eine Alternative wäre:

Lesen Verriegelung - wie oben. Schreibverriegelung wie folgt (Pseudo-Code):

- Lock mutex
- Busy loop until the samaphore is not taken AT ALL:
-- wait, release.
-- Release returns value; 
-- if value N-1 then break loop.
-- yield (give up CPU cycle) by using Sleep(1) or alternative
- Do write
- Release mutex

Es ist zu beachten, dass eine effizientere Vorgehensweise ist möglich, da sich hier: http: //en.wikipedia.org/wiki/Readers-writers_problem#The_second_readers-writers_problem Suchen Sie nach den Worten „Diese Lösung ist nicht optimal“ in dem Artikel oben.

Answer 2

Fenster enthalten keine Cross-Prozess Reader-Writer Sperre. Eine Kombination von Semaphore und Mutex konnte Konstrukt diejenigen verwendet werden (die Mutex von einem Schriftsteller für den exklusiven Zugriff oder durch einen Reader gehalten wird, die dann die Semaphore verwendet andere Leser, dh Autoren freigeben würde entweder für den Mutex und Leser warten auf gerade) .

Wenn jedoch Behauptung erwartet wird, gering zu sein (dh kein Thread eine Sperre für lange), dann mutual exclusion noch schneller sein kann: die zusätzliche Komplexität der Lese-Schreib-Sperre überwältigt jeden Vorteil, dass mehrere Leser in (A. Leser-Schreiber-Sperre nur schneller sein wird, wenn es viel mehr Leser und Schlösser sind für erhebliche gehaltene zeit aber nur Ihre Profilierung kann dies bestätigen.)

Answer 3

Ich habe diese Klasse erstellt basierend auf Pavel Antwort. Ich habe es nicht ausgiebig noch nicht getestet, aber ich habe eine einfache WinForms-Anwendung erstellt, es zu testen und so weit es funktioniert gut.

Bitte beachten Sie, dass es eine Semaphore verwendet, so dass es nicht reentrancy nicht unterstützt.

public class CrossProcessReaderWriterLock
{
    private readonly string _name;
    const int _maxReaders = 10;

    readonly Mutex     _mutex;
    readonly Semaphore _semaphore;

    public CrossProcessReaderWriterLock(string name)
    {
        _name = name;
        _mutex     = new Mutex(false, name + ".Mutex");
        _semaphore = new Semaphore(_maxReaders, _maxReaders, name + ".Semaphore");
    }

    public void AcquireReaderLock()
    {
        //Log.Info($"{_name} acquiring reader lock...");

        _mutex    .WaitOne();
        _semaphore.WaitOne();
        _mutex    .ReleaseMutex();

        //Log.Info($"{_name} reader lock acquired.");
    }

    public void ReleaseReaderLock()
    {
        _semaphore.Release();

        //Log.Info($"{_name} reader lock released.");
    }

    public void AcquireWriterLock()
    {
        //Log.Info($"{_name} acquiring writer lock...");

        _mutex.WaitOne();

        for (int i = 0; i < _maxReaders; i++)
            _semaphore.WaitOne(); // drain out all readers-in-progress

        _mutex.ReleaseMutex();

        //Log.Info($"{_name} writer lock acquired.");
    }

    public void ReleaseWriterLock()
    {
        for (int i = 0; i < _maxReaders; i++)
            _semaphore.Release();

        //Log.Info($"{_name} writer lock released.");
    }
}

Answer 4

System.Threading.Mutex hat eine Mutex, die für den innerProzessKommunikation verwendet werden kann. Wenn Sie Funktionalität möchten, dass es nicht unterstützt, kann es über einen Mutex implementiert werden.

Answer 5

Haben Sie sich System.Threading.ReaderWriteLock? Hier ist der MSDN Link.