Versão c # da palavra-chave sincronizada do java?

O c # tem sua própria versão da palavra-chave "sincronizada" do java?

Ou seja, em java, pode ser especificado para uma função, um objeto ou um bloco de código, assim:

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

ou

public void doImportantStuff() {
   // trivial stuff

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

Primeiro - a maioria das aulas nunca precisará ser segura para threads. Use YAGNI : aplique a segurança de threads apenas quando você souber que realmente vai usá-lo (e testá-lo).

Para o material no nível do método, existe [MethodImpl]:

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

Isso também pode ser usado em acessadores (propriedades e eventos):

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

Observe que os eventos do tipo campo são sincronizados por padrão, enquanto as propriedades implementadas automaticamente não são :

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

Pessoalmente, não gosto da implementação de MethodImplcomo ela bloqueia thisou typeof(Foo)- o que é contra as melhores práticas. A opção preferida é usar seus próprios bloqueios:

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

Observe que, para eventos do tipo campo, a implementação de bloqueio depende do compilador; em compiladores mais antigos da Microsoft, é um lock(this)/ lock(Type)- no entanto, em compiladores mais recentes, ele usaInterlocked atualizações -, portanto, são seguros para threads sem as partes desagradáveis.

Isso permite um uso mais granular e permite o uso de Monitor.Wait /Monitor.Pulse etc para se comunicar entre os threads.

Uma entrada de blog relacionada ( revisitada posteriormente ).

static object Lock = new object();

lock (Lock) 
{
// do stuff
}

O c # tem sua própria versão da palavra-chave "sincronizada" do java?

Não. No C #, você explicitamente lockrecursos nos quais deseja trabalhar de forma síncrona em threads assíncronos.lockabre um bloco; não funciona no nível do método.

No entanto, o mecanismo subjacente é semelhante, pois lockfunciona invocando Monitor.Enter(e subseqüentemente Monitor.Exit) no tempo de execução. Java funciona da mesma maneira, de acordo com a documentação da Sun .

Tome nota, com caminhos completos da linha: [MethodImpl(MethodImplOptions.Synchronized)]deve parecer

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

Você pode usar a lockinstrução. Eu acho que isso só pode substituir a segunda versão. Além disso, lembre-se de que ambos synchronizede lockprecisa operar em um objeto.