C# version of java's synchronized keyword?

java

thread-safety

synchronization

lock-statement

byAlex Kataev·Aug 27, 2024

Employ C#'s lock paired with a private object for securing operations in a multi-threaded environment:

private object _sync = new object();

public void SyncMethod()
{
    lock (_sync)
    {
        // Secure, multi-thread friendly code here
    }
}

This handy lock setup mirrors Java's synchronized for securing those risky areas against concurrent meddling.

Unlocking method-level synchronization

When you crave method-level synchronization in C#, [MethodImpl(MethodImplOptions.Synchronized)] is your go-to ingredient:

using System.Runtime.CompilerServices;

[MethodImpl(MethodImplOptions.Synchronized)]
public void Method()
{
    // Bullet-proof method, akin to synchronized in Java
}

Apply this sparingly though, our friend here can lead to performance bottleneck and its scope is confined to our method.

Granular synchronization with 'lock'

The lock statement in C# grants finer control, allowing that extra layer of protection at the method level or within code blocks, adapt as needed:

public void PartialSyncMethod()
{
    // Divert traffic here, no need for a red light yet

    lock (_sync)
    {
        // Proceed with caution, synchronized roadwork ahead
    }

    // It's a smooth drive again, no restrictions here
}

Mastering thread communication

The Monitor class aids in weaving more intricate thread interaction via Monitor.Wait and Monitor.Pulse:

lock (_sync)
{
    // Hold up, wait for a go-ahead
    while (!greenSignal)
    {
        Monitor.Wait(_sync);
    }

    // Carry out orders, execute!

    // Announce that actions are over, next please
    Monitor.Pulse(_sync);
}

Seize tighter reins of thread signaling.

Steer clear of synchronization pitfalls

With the lock plan, its crucial to banish locking on this or typeof(Foo). External code might pilfer away your lock access. Reinforce your lock with a dedicated guardian object, say _sync.

In addition, Interlocked class functions safeguard field-like events in C# via atomic operations, which ensures thread safety.

Under the masks

Hidden behind the scenes, the C# lock statement pulls the strings with Monitor.Enter and Monitor.Exit, just as synchronized does in Java. Java converts should find this a familiar playground.