Méthode de verrouillage en c#

J'ai une classe avec ces trois méthodes. Cette classe est utilisée par de nombreux fils.
Je voudrais que le Method1 attendre, si Method2 et/ou Method3 sont en cours d'exécution dans tous les threads.
Des suggestions?

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
    }
}
Method2 et Method3 peut exécuter simultanée? Le et/ou implique que, d'une certaine façon.

OriginalL'auteur Emanuele Mazzoni | 2013-02-20

  1. 12

    Si j'ai bien compris, vous avez besoin de quelque chose comme ceci:

    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
    }
}

    Cela permet method3 à exécuter si method2 est en cours d'exécution, et vice-versa, tandis que method1 doit attendre les deux. Bien sûr, method2 et 3 ne sera pas exécuté tout en 1 est en cours d'exécution.

    oui, merci, j'avais raté le fait que les méthodes sont statiques...

    OriginalL'auteur Paolo Tedesco

  2. 11

    La mise en œuvre actuelle de votre serrure est complètement inutile, parce que chaque thread se bloque sur un objet différent.

    Le verrouillage se fait généralement avec un champ en lecture seule qui est initialisé qu'une seule fois.

    Comme cela, vous pouvez facilement verrouiller plusieurs méthodes:

    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
        }
    }
}

    OriginalL'auteur Daniel Hilgarth

  3. 11

    Je vous suggère un ReaderWriterLockSlim (http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx)

    Similaire pour les opérations de lecture, la Méthode 2 et Method3 peut se produire en parallèle, tout en Method1 (comme une opération d'écriture) aurait besoin d'attendre pour ceux à la fin.
    Ce n'est pas l'ordinaire de lecture/écriture de la simultanéité de la situation, mais la logique est similaire.

    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, je ne connaissais pas celui-ci 🙂

    OriginalL'auteur Coral Doe

  4. 3

    Si vous êtes multi-threading puis le lock doit être accessible à tous les threads. Par conséquent, dans ce cas, vos serrures doit être statique pour les méthodes statiques pour le voir.

    Votre configuration actuelle fera un nouveau verrouillage de l'objet pour chaque thread. Par conséquent, en fournissant maintenant la synchronisation.

    OriginalL'auteur Davin Tryon