Ist etwas falsch mit warten Task.Run (() => semaphore.WaitOne())?

Question

Der Titel sagt alles. Ist etwas falsch mit await Task.Run(() => semaphore.WaitOne());? System.Threading.Semaphore ist nicht Thread-affine, also würde ich nicht denken, dass es ein Problem geben würde. Ich weiß, dass die SemaphoreSlim Klasse verfügbar ist, aber ich muss die prozessübergreifende Synchronisierung durchführen, und SemaphoreSlim tut das nicht.

Oder kann/sollte ich meinen eigenen benutzerdefinierten Typ von WaitHandle erstellen?

Answer 1

Wenn Sie versuchen, die Benutzeroberfläche, die auf zu halten, während hier für die Semaphore warten, könnte es Sinn machen, aber es gibt einen Haken: "Semaphores don't have owners". Wenn Sie den Semaphor zwischen zwei Prozessen freigeben und der andere Prozess abstürzt, ohne Semaphore.Release(), aufzurufen, geht die Eigentumsrechte an der freigegebenen Ressource verloren. Der verbleibende Prozess ist möglicherweise nicht in der Lage, es erneut zu erfassen.

IMO, die Mutex Semantik wäre hier angemessener, aber mit Mutex würden Sie Thread-Affinität benötigen. Vielleicht können Sie die Mutex erwerben, auf die Ressource zugreifen und sie auf dem gleichen Thread Mitteilung:

await Task.Factory.StartNew(() => 
{ 
    mutex.WaitOne(); 
    try 
    { 
     // use the shared resource 
    } 
    finally 
    { 
     mutex.ReleaseMutex(); 
    } 
}, TaskCreationOptions.LongRunnning); 

Wenn das nicht möglich ist (zB weil Sie die gemeinsam genutzte Ressource auf dem Haupt-UI-Thread zugreifen müssen), könnten Sie Verwenden Sie einen dedizierten Thread für den Mutex. Dies kann mit einem benutzerdefinierten Aufgabenplaner, z.B. Stephen Toub der StaTaskScheduler mit numberOfThreads:1 (der Helfer-Thread muss nicht STA in diesem Fall gemacht werden):

using (var scheduler = new StaTaskScheduler(numberOfThreads: 1)) 
{ 
    await Task.Factory.StartNew(
     () => mutex.WaitOne(), 
     CancellationToken.None, 
     TaskCreationOptions.None, 
     scheduler); 
    try 
    { 
     // use the shared resource on the UI thread 
    } 
    finally 
    { 
     Task.Factory.StartNew(
      () => mutex.ReleaseMutex(), 
      CancellationToken.None, 
      TaskCreationOptions.None, 
      scheduler).Wait(); 
    } 
} 

aktualisiert, wenn Sie über WinRT betroffen sind (dh .NET for Windows Store Apps) oder Windows Phone, dann Task.Factory.StartNew w/TaskCreationOptions.LongRunning ist immer noch da, Sie können es anstelle von new Thread() mit StaTaskScheduler oder etwas wie meine ThreadWithSerialSyncContext verwenden, wenn Sie einen Hintergrund-Thread mit Affinität benötigen.