Version C # du mot-clé synchronisé de Java?

C # a-t-il sa propre version du mot-clé "synchronisé" java?

C'est-à-dire en java, il peut être spécifié soit pour une fonction, un objet ou un bloc de code, comme ceci:

public synchronized void doImportantStuff() {
   // dangerous code goes here.
}

ou

public void doImportantStuff() {
   // trivial stuff

   synchronized(someLock) {
      // dangerous code goes here.
   }
}

Premièrement - la plupart des classes n'auront jamais besoin d'être thread-safe. Utilisez YAGNI : n'appliquez la sécurité des threads que lorsque vous savez que vous allez réellement l'utiliser (et le tester).

Pour les choses au niveau de la méthode, il y a [MethodImpl]:

[MethodImpl(MethodImplOptions.Synchronized)]
public void SomeMethod() {/* code */}

Cela peut également être utilisé sur les accesseurs (propriétés et événements):

private int i;
public int SomeProperty
{
    [MethodImpl(MethodImplOptions.Synchronized)]
    get { return i; }
    [MethodImpl(MethodImplOptions.Synchronized)]
    set { i = value; }
}

Notez que les événements de type champ sont synchronisés par défaut, tandis que les propriétés implémentées automatiquement ne le sont pas :

public int SomeProperty {get;set;} // not synchronized
public event EventHandler SomeEvent; // synchronized

Personnellement, je n'aime pas l'implémentation MethodImplcar elle se verrouille thisou typeof(Foo)- ce qui est contraire aux meilleures pratiques. L'option préférée consiste à utiliser vos propres verrous:

private readonly object syncLock = new object();
public void SomeMethod() {
    lock(syncLock) { /* code */ }
}

Notez que pour les événements de type champ, l'implémentation de verrouillage dépend du compilateur; dans les anciens compilateurs Microsoft, il s'agit d'un lock(this)/ lock(Type)- cependant, dans les compilateurs plus récents, il utilise desInterlocked mises à jour - donc thread-safe sans les parties désagréables.

Cela permet une utilisation plus granulaire et permet l'utilisation de Monitor.Wait/ Monitor.Pulseetc pour communiquer entre les threads.

Une entrée de blog connexe ( revisitée plus tard ).

static object Lock = new object();

lock (Lock) 
{
// do stuff
}

C # a-t-il sa propre version du mot-clé "synchronisé" java?

Non. En C #, vous avez explicitement des lockressources sur lesquelles vous souhaitez travailler de manière synchrone sur des threads asynchrones. lockouvre un bloc; cela ne fonctionne pas au niveau de la méthode.

Cependant, le mécanisme sous-jacent est similaire car lockfonctionne en invoquant Monitor.Enter(et par la suite Monitor.Exit) sur le runtime. Java fonctionne de la même façon, selon la documentation Sun .

Prenez note, avec des chemins complets la ligne: [MethodImpl(MethodImplOptions.Synchronized)]devrait ressembler

[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.Synchronized)]

Vous pouvez utiliser l' lockinstruction à la place. Je pense que cela ne peut que remplacer la deuxième version. Rappelez - vous aussi que les deux synchronizedet ont lockbesoin pour fonctionner sur un objet.