Combien de temps un C# attente de verrouillage, et en ce que si le code se bloque pendant le lock?

j'ai vu le code suivant, et je voulais l'utiliser pour une activité simple qui ne peut être exécutée à la fois, et de ne pas se produire fréquemment (donc la chance de se produisant deux fois à un moment, c'est très petit, mais on ne sait jamais).

Donc le code:

 //class variable
    private static object syncRoot = new object();

    //in a method:
    lock (syncRoot)
    {
     DoIt();
    }

quand un autre thread arrive et veut exécuter le code, combien de temps faudra-il attendre jusqu'à ce que le verrou est libéré? pour toujours, ou vous pouvez en quelque sorte de définir un délai d'attente?

et la seconde: si l' DoIt() méthode lève une exception, la serrure est encore sorti?

InformationsquelleAutor Michel | 2011-05-18
  1. 73

    quand un autre thread arrive et veut exécuter le code, combien de temps faudra-il attendre jusqu'à ce que le verrou est libéré?

    lock va bloquer le thread en essayant de pénétrer dans l'écluse indéfiniment jusqu'à ce que l'objet est verrouillé sur est libéré.

    pouvez vous en quelque sorte humide d'un délai d'attente?

    Si vous avez besoin de spécifier un délai d'attente, utilisez Moniteur.TryEnter comme dans

    if(Monitor.TryEnter(obj, new TimeSpan(0, 0, 1))) {
    try {
        body 
    }
    finally {
        Monitor.Exit(obj);
    }
}

    si le DoIt() la méthode lève une exception, la serrure est encore sorti?

    Oui, un lock(obj) { body } est traduite en

    bool lockWasTaken = false;
var temp = obj;
try { Monitor.Enter(temp, ref lockWasTaken); { body } }
finally { if (lockWasTaken) Monitor.Exit(temp); }

    Pour obtenir des détails plus précis sur ce qui peut arriver lorsqu'une exception est levée, voir Les verrous et les exceptions ne pas mélanger.

    • Pour un semi-automatique de mise en œuvre, vous pouvez consulter informit.com/articles/article.aspx?p=1231461 et interagissent-sw.co.royaume-uni/iangblog/2004/03/23/verrouillage (en utilisant le/disposer d'automatiser une partie de la saisie).
    • Un avertissement juste! L'instruction n'est pas sûr à 100% (beaucoup ont tendance à penser que c'est!): L'aide de l'instruction ne Disposer d'appel s'il a reçu le IDisposable-référence. Ce qui se passe peu de temps après l'instruction à l'intérieur de la à l'aide de parenthèses, c'est à dire using (/*this stuff*/), complète. Depuis il n'y a absolument aucune obligation pour l'atomicité (cette affirmation peut être arbitrairement long), quelque chose peut se produire dans ce qui empêche l' (généré par le compilateur) à l'aide de code de la réception de votre habile IDisposable de référence. (tl;dr: gardez à l'aide de relevés simple - mettre les trucs compliqués à l'intérieur de son corps.)
    InformationsquelleAutor jason
  2. 31

    Comme mentionné, une serrure attendre éternellement, ce qui est un risque de blocages.

    Le mécanisme de prédilection est (et note de l' ref):

    bool lockTaken = false;
try {
    Monitor.TryEnter(lockObj, timeout, ref lockTaken);
    if(!lockTaken) throw new TimeoutException(); //or compensate
    //work here...
} finally {
    if(lockTaken) Monitor.Exit(lockObj);
}

    Cela évite le risque de ne pas relâcher le verrou dans certains bord-cas.

    La finally (qui existe dans n'importe quelle mise en œuvre) assure le verrouillage est libéré, même dans des conditions d'erreur.

    • Je tiens à ajouter que beaucoup de programmeurs ajouter que, finalement, déclaration de l'habitude, mais une habitude, il ne devrait pas être: "la libération de la serrure en cas d'erreur" n'est pas auto-magiquement mieux qu'à une impasse. C'est quelque chose qui doit être évalué au cas par cas. Dans une critique de sécurité scénario d'enlever le verrou dans un état d'erreur pourrait être dangereux de détection des morts-verrouillé processus et d'effectuer une sorte de procédure de recouvrement ne peut parfois être plus sûr que de le libérer le verrou. "Parfois" est le mot clé.
    InformationsquelleAutor Marc Gravell
  3. 9

    Un simple lock(syncRoot) attendra toujours.

    Vous pouvez le remplacer par 

    if (System.Threading.Monitor.TryEnter(syncRoot, 1000))
{
     try
     {
         DoIt();
     }
     finally
     {
         System.Threading.Monitor.Exit(syncRoot);
     }
}

    Chaque thread doit s'assurer d'exception-safe de verrouillage.

    Noter que la norme lock(syncRoot) {} est réécrit afin de Monitor.Enter(syncRoot) et un try/finally

    • En c# 4.0 ciblage .NET 4 une autre surcharge est appelé - le ref lockTaken version
    InformationsquelleAutor Henk Holterman
  4. 3

    La serrure attendre éternellement, comme Henk dit. Une exception tout de même les débloquer. Il est mis en œuvre en interne avec un try-finally bloc.

    InformationsquelleAutor Mr47
  5. 1

    Vous devriez prendre du recul et demandez-vous pourquoi vous laisser une exception à partir d'une méthode ont quelque chose à dire de plus quand un Monitor vous Enter est Exited. Si il ya même une chance que DoIt() peut lever une exception (et je dirais que, si possible, de vous ré-écrire DoIt() de sorte qu'elle n'est pas), alors vous devriez avoir un try/catch bloc à l'intérieur de la serrure() instruction de sorte que vous pouvez vous assurer que vous effectuez le nettoyage nécessaire.

    • Je suis d'accord cette mise en œuvre est une solution simple qui ne nécessite pas un bloc finally.
    InformationsquelleAutor dlev
  6. 0

    Connaître les conditions nécessaires à l'impasse de prendre place. Toujours utiliser le Moniteur vs de Verrouillage pour éviter les blocages.

    Combien de temps un C# attente de verrouillage, et en ce que si le code se bloque pendant le lock?

    InformationsquelleAutor dot.net5000
  7. -1

    Jason réponse est excellente, voici une façon à l'envelopper de faire l'appel plus simple.

        private void LockWithTimeout(object p_oLock, int p_iTimeout, Action p_aAction)
    {
        Exception eLockException = null;
        bool bLockWasTaken = false;
        try
        {
            Monitor.TryEnter(p_oLock, p_iTimeout, ref bLockWasTaken);
            if (bLockWasTaken)
                p_aAction();
            else
                throw new Exception("Timeout exceeded, unable to lock.");
        }
        catch (Exception ex)
        {
            //conserver l'exception
            eLockException = ex;
        }
        finally 
        { 
            //release le lock
            if (bLockWasTaken) 
                Monitor.Exit(p_oLock); 

            //relancer l'exception
            if (eLockException != null)
                throw new Exception("An exception occured during the lock proces.", eLockException);
        }
    }

    et puis, l'utiliser de cette façon:

            //ajouter à la liste des fiches à loader
        LockWithTimeout(m_lLoadingQueue, 3600, () =>
        {
            m_lLoadingQueue.Add(p_efEcranFiche);
        });
    InformationsquelleAutor Sam L.