Instruction C# lock, quel objet à verrou?

Comment et ce que vous verrouillage dépend de ce que vous faites.

Disons que vous travaillez avec un dispositif de type - dire une machine à café. Vous pourriez avoir une classe qui ressemble à ceci:

public CoffeeMaker {
    private IntPtr _coffeeHandle;
    private Object _lock = new Object();
}

Dans ce cas, vous êtes à la protection de l'accès à la _coffeeHandle - un pointeur/poignée pour un appareil physique réel, donc c'est plutôt facile:

public int AvailableCups {
    get {
        lock (_lock) {
            return GetAvailableCups(_coffeeHandle); //P/Invoked
        }
    }
}

public void Dispense(int nCups)
{
    lock (_lock) {
        int nAvail = GetAvailableCups(_coffeeHandle);
        if (nAvail < nCups) throw new CoffeeException("not enough coffee.");
        Dispense(_coffeeHandle, nCups); //P/Invoked
    }
 }

Donc, si je suis en cours d'exécution d'une application multithread, j' (probablement) ne veulent pas lire le nombre de tasses sont disponibles alors que je suis de distribution (c'est peut-être une erreur de matériel (hardware). En protégeant les accès à la poignée, je peux vous assurer qu'. Aussi, je ne peux pas être demandé de renoncer alors que je suis déjà de distribution - qui serait mauvais, de sorte que sa protégée. Finalement, je ne suis pas renoncer, sauf si j'ai assez de café disponibles et vous avez remarqué que je ne pas utiliser mon public de la propriété à vérifier que - de cette façon, l'action de s'assurer il y a assez de café et de distribution sont liées ensemble. Le mot magique est atomique - ils ne peuvent pas être coupés en dehors, sans créer de problèmes.

Vous utilisez un objet statique comme un verrou si vous en avez une et une seule instance d'une ressource qui doit protéger. Pensez, "puis-je avoir un singleton?" et qui servira de ligne directrice pour quand vous pourriez avoir besoin d'une statique de la serrure. Par exemple, disons que la Cafetière est un constructeur privé. Au lieu de cela, vous avez une méthode de fabrique que des constructions de machines à café:

static Object _factLock = new Object();

private CoffeeMaker(IntPtr handle) { _coffeeHandle = handle; }

public static CoffeeMaker GetCoffeeMaker()
{
    lock (_factLock) {
        IntPtr _handle = GetCoffeeMakerHandle(); //P/Invoked
        if (_handle == IntPtr.Zero) return null;
        return new CoffeeMaker(_handle);
    }
 }

Maintenant, dans ce cas, il se sent comme la Cafetière doit mettre en œuvre IDisposable de sorte que le manche est pris en charge, parce que si vous ne relâchez pas c'est que quelqu'un ne pourrait pas obtenir leur café.

Il y a quelques problèmes, bien - peut-être que si il n'y a pas assez de café, nous devrions en faire plus - et qui prend du temps. Diable - la distribution de café prend beaucoup de temps, c'est pourquoi nous faisons attention à la protection de nos ressources. Maintenant, vous pensez vraiment que tout cela bouilloire truc devrait être dans un thread qui lui est propre et qu'il devrait être un événement qui obtient déclenché lorsque le café est fait, et puis il commence à devenir compliqué et que vous comprenez l'importance de savoir ce que vous êtes le verrouillage de et quand, de sorte que vous n'avez pas la fabrication du bloc de café, parce que vous avez demandé combien de tasses sont là.

Et si les mots "d'impasse", "atomique", "surveiller", "attendre", et "pulse" tous les sons étrangers à vous, vous devriez envisager de faire des lectures sur le multitraitement/multithreading, en général, et de voir si vous pouvez résoudre la juste barbershop problème ou la salle à manger problème de philosophes, à la fois la quintessence des exemples de conflits de ressources.

1: l'objet que vous utilisez définit /est défini par la serrure de la granularité vous tentez d'appliquer. Si c'est "rien d'appel à l'encontre de l'instance en cours", puis un private readonly object syncLock = new object() serait raisonnable. Si c'est "n'importe quel code, indépendamment de l'instance" (statique, en particulier), puis private readonly static object syncLock = new object(). Parfois, il y a un évident "chose" que vous essayez de protéger qui servira également: une liste, une file d'attente, etc. Le principal mal les décisions sont: this, typeof(...), tout string, tout type de valeur que vous êtes la boxe pour chaque lock, et tout ce que vous avez une fuite à l'extérieur de l'instance.

2: Monitor.Wait communiqués de les serrures de la thread en cours, en attente, soit une "impulsion" ou un délai d'attente, à quel point il se réveille et se joint à la file d'attente pour retrouver les verrous il avait (notez le "s" il est pour re-entrancy). Cela signifie que les deux threads peuvent utiliser un Monitor à signal entre eux, par des impulsions et d'attente.

3: sans rapport; mais, fondamentalement, "vérifier un indicateur périodiquement, et au moment d'être pulsé"