Methodensperre in C#

Question

Ich habe eine Klasse mit diesen drei Methoden. Diese Klasse wird von vielen Threads verwendet. Ich möchte die Method1 warten, wenn Method2 und/oder Method3 in beliebigen Threads ausgeführt werden. Irgendwelche Vorschläge?

public class Class1 
{ 
    public static void Method1() 
    { 
     Object lockThis = new Object(); 

     lock (lockThis) 
     { 
      //Body function 
     } 
    } 

    public static void Method2() 
    { 
     //Body function 
    } 

    public static void Method3() 
    { 
     //Body function 
    } 
} 

Answer 1

Wenn ich richtig verstanden habe, müssen Sie etwas wie folgt aus:

static object lockMethod2 = new object(); 
static object lockMethod3 = new object(); 

public static void Method1() 
{ 
    lock (lockMethod2) 
    lock (lockMethod3) 
    { 
     //Body function 
    } 
} 

public static void Method2() 
{ 
    lock (lockMethod2) 
    { 
     //Body function 
    } 
} 

public static void Method3() 
{ 
    lock (lockMethod3) 
    { 
     //Body function 
    } 
} 

Dies ermöglicht method3 auszuführen, wenn method2 und umgekehrt läuft, während method1 für beide warten müssen. Natürlich werden Methode 2 und 3 nicht ausgeführt, während 1 ausgeführt wird.

Answer 2

Wenn Sie Multi-Threading verwenden, muss die lock für alle Threads zugänglich sein. Daher müssen Ihre Sperren in diesem Fall statisch sein, damit die statischen Methoden sie sehen können.

Ihr aktuelles Setup erstellt ein neues Sperrobjekt für jeden Thread. Daher jetzt Synchronisation bereitstellen.

Answer 3

Die aktuelle Implementierung Ihrer Sperre ist völlig nutzlos, da jeder Thread auf einem anderen Objekt gesperrt wird.
Das Sperren erfolgt normalerweise mit einem schreibgeschützten Feld, das nur einmal initialisiert wird.
wie diese, können Sie leicht mehrere Methoden sperren:

public class Class1 
{ 
    private static readonly object _syncRoot = new object(); 

    public static void Method1() 
    { 
     lock (_syncRoot) 
     { 
      //Body function 
     } 
    } 

    public static void Method2() 
    { 
     lock (_syncRoot) 
     { 
      //Body function 
     } 
    } 

    public static void Method3() 
    { 
     lock (_syncRoot) 
     { 
      //Body function 
     } 
    } 
} 

Answer 4

ich ein ReaderWriterLockSlim (http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx)

Ähnlich Leseoperationen vorschlagen würde, Methode 2 und Method3 parallel, während Method1 (wie ein auftreten kann Schreibvorgang) müsste warten, bis diese fertig sind. Es ist nicht die reguläre Gleichzeitigkeit von Lesen/Schreiben, aber die Logik ist ähnlich.

public class Class1 
{ 
    private ReaderWriterLockSlim methodLock = new ReaderWriterLockSlim(); 
    public static void Method1() 
    { 
     methodLock.EnterWriteLock(); 
     try 
     { 
      //Body function 
     } 
     finally 
     { 
      cacheLock.ExitWriteLock(); 
     } 
    } 

    public static void Method2() 
    { 
     methodLock.EnterReadLock(); 
     try 
     { 
      //Body function 
     } 
     finally 
     { 
      methodLock.ExitReadLock(); 
     } 
    } 

    public static void Method3() 
    { 
     methodLock.EnterReadLock(); 
     try 
     { 
      //Body function 
     } 
     finally 
     { 
      methodLock.ExitReadLock(); 
     } 
    } 
}