¿Versión C # de la palabra clave sincronizada de Java?

¿C # tiene su propia versión de la palabra clave "sincronizada" de Java?

Es decir, en Java se puede especificar a una función, un objeto o un bloque de código, así:

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

o

public void doImportantStuff() {
   // trivial stuff

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

Primero: la mayoría de las clases nunca necesitarán ser seguras para subprocesos. Use YAGNI : solo aplique seguridad de hilo cuando sepa que realmente lo va a usar (y probarlo).

Para las cosas de nivel de método, hay [MethodImpl]:

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

Esto también se puede usar en accesores (propiedades y eventos):

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

Tenga en cuenta que los eventos similares a campos se sincronizan de manera predeterminada, mientras que las propiedades implementadas automáticamente no lo son :

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

Personalmente, no me gusta la implementación MethodImplya que se bloquea thiso typeof(Foo), lo que va en contra de las mejores prácticas. La opción preferida es usar sus propios bloqueos:

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

Tenga en cuenta que para eventos de tipo campo, la implementación de bloqueo depende del compilador; en los compiladores de Microsoft más antiguos es un lock(this)/ lock(Type), sin embargo, en los compiladores más recientes usaInterlocked actualizaciones, por lo que es seguro para subprocesos sin las partes desagradables.

Esto permite un uso más granular y permite el uso de Monitor.Wait/ Monitor.Pulseetc para comunicarse entre subprocesos.

Una entrada de blog relacionada (luego revisada ).

static object Lock = new object();

lock (Lock) 
{
// do stuff
}

¿C # tiene su propia versión de la palabra clave "sincronizada" de Java?

No. En C #, explícitamente lockrecursos en los que desea trabajar sincrónicamente a través de subprocesos asincrónicos. lockabre un bloque No funciona a nivel de método.

Sin embargo, el mecanismo subyacente es similar ya que lockfunciona invocando Monitor.Enter(y posteriormenteMonitor.Exit ) en el tiempo de ejecución. Java funciona de la misma manera, de acuerdo a la documentación de Sun .

Tome nota, con caminos completos la línea: [MethodImpl(MethodImplOptions.Synchronized)]debería verse como

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

Puede usar la lockdeclaración en su lugar. Creo que esto solo puede reemplazar la segunda versión. Además, recuerde que tanto synchronizedy locknecesidad de trabajar con un objeto.