Methode lock-in c#

Ich habe eine Klasse mit diesen drei Methoden. Diese Klasse wird von vielen threads.
Ich möchte die Methode1 zu warten, wenn Methode2 und/oder Methode3 laufen in alle threads.
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
    }
}
  • Methode2 und Methode3 gleichzeitige ausführen kann? Die und/oder impliziert, dass in irgendeiner Weise.
InformationsquelleAutor Emanuele Mazzoni | 2013-02-20
  1. 13

    Wenn ich das richtig verstanden habe, brauchen Sie so etwas wie dieses:

    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 Methode3 ausgeführt werden, wenn methode2 ausgeführt wird, und Umgekehrt, während methode1 warten müssen, für beide. Natürlich, method2 und 3 werden nicht ausgeführt, während 1 ausgeführt wird.

    • ja, danke, hatte ich übersehen die Tatsache, dass die Methoden statisch waren...
    InformationsquelleAutor Paolo Tedesco
  2. 11

    Die aktuelle Umsetzung der sperren ist völlig nutzlos, weil jeder thread lock auf ein anderes Objekt.

    Die Verriegelung erfolgt in der Regel mit einem readonly-Feld, das initialisiert nur einmal.

    Wie diese, können Sie leicht schließen mehrere Methoden:

    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
        }
    }
}
    InformationsquelleAutor Daniel Hilgarth
  3. 11

    Ich würde vorschlagen, eine ReaderWriterLockSlim (http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx)

    Ähnlich zu Lesen, operations, Methode 2 und Methode3 kann auftreten, in parallele, während Method1 (wie eine write-operation) benötigen würde, zu warten, bis diese fertig zu stellen.
    Es ist nicht die normale lese - /schreib-Parallelität situation, aber die Logik ist ähnlich.

    public class Class1
{
    private ReaderWriterLockSlim methodLock = new ReaderWriterLockSlim();
    public static void Method1() 
    {
        methodLock.EnterWriteLock();
        try
        {
            //Body function
        }
        finally
        {
            methodLock.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();
        }
    }
}
    • +1, ich wusste das nicht ein 🙂
    InformationsquelleAutor Coral Doe
  4. 3

    Wenn du multi-threading-dann die lock hat Zugriff auf alle threads. Also, in diesem Fall, Ihre Schlösser muss statisch sein für die statischen Methoden, um es zu sehen.

    Ihre aktuelle Konfiguration wird ein neues lock-Objekt für jeden thread. Daher bietet jetzt die Synchronisierung.

    InformationsquelleAutor Davin Tryon
Schreibe einen Kommentar