The lock statement

Learn critical section protection with lock.

The lock statement

The lock statement protects a critical section. lock (_sync) { /* only one thread */ } lets only one thread enter at a time; others wait.

lock is a shortcut for Monitor.Enter and Monitor.Exit. The lock object is usually private readonly object _sync = new();; locking on this or a string is dangerous.

lock and atomicity

lock makes the code inside the block atomic; multiple threads cannot modify the same data at the same time. This prevents race conditions in operations like counter increment (counter++) or list appends.

lock is costly; for very small work, lighter alternatives such as Interlocked may be preferred. The right choice balances performance and safety.

Exercise Increment a counter with lock

Declare private static readonly object _sync = new object(); and private static int _counter = 0;. In Main create 2 threads, each calling lock (_sync) { _counter++; }. Wait with Join. Finally print Console.WriteLine($"Counter: {_counter}");. (2 threads * 1 increment = 2 expected.)

Show example solution

{_counter}");
Example solution:
using System;
using System.Threading;

class Program
{
    private static readonly object _sync = new object();
    private static int _counter = 0;

    static void Main()
    {
        Thread t1 = new Thread(() => { lock (_sync) { _counter++; } });
        Thread t2 = new Thread(() => { lock (_sync) { _counter++; } });
        t1.Start();
        t2.Start();
        t1.Join();
        t2.Join();
        Console.WriteLine($"Counter: {_counter}");
    }
}

Test yourself

Match the lock concepts

lock (_sync)

Critical section
Monitor.Enter

Basis of lock
private readonly object _sync

Lock object
this (locking)

Dangerous
Which object should lock use?
- private readonly object
- this
- string literal
- typeof(int)
Show answer

private readonly object — Correct. A private readonly object is the safest lock.

Complete the lock statement

____ (_sync) { counter++; }

Show answer

lock (_sync) { counter++; }

Next lesson: Interlocked

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies