C# lock KeywordUse the lock keyword to restrict concurrent access and develop correct threaded programs.
This keyword is used in threading. It restricts code from being executed by more than one thread at the same time. This makes threaded programs reliable.KeywordsThreads
The lock statement uses a special syntax form to restrict concurrent access. Lock is compiled into a lower-level implementation based on threading primitives.
The Main method creates 10 new threads, and then calls Start on each one. Please examine method "A" to see the lock statement.
Method A: This uses lock on an object. Each invocation of this method accesses the threading primitives implemented by the lock.
Then: Only one method A can call the statements protected by the lock at a single time, regardless of the thread count.
Info: Method A is invoked 10 times. The output shows the protected method region is executed sequentially—about 100 milliseconds apart.ThreadStartSleep
Note: If you remove the lock statement, the methods will be executed all at once, with no synchronization.Static
C# program that uses lock statement
static readonly object _object = new object();
static void A()
// Method A: lock on the readonly object.
// ... Inside the lock, sleep for 100 milliseconds.
// ... This is thread serialization.
static void Main()
// Create 10 new threads.
for (int i = 0; i < 10; i++)
ThreadStart start = new ThreadStart(A);
Let's examine the intermediate representation for the lock statement. In compiler theory, high-level source texts are translated to lower-level streams of instructions.IL
Tip: The lock statement here is transformed into calls to the static methods Monitor.Enter and Monitor.Exit.
Also: The lock is actually implemented with a try-finally construct. This uses the exception handling control flow.TryFinally
Intermediate representation for method using lock:
.method private hidebysig static void A() cil managed
.locals init (
 object obj2)
L_0000: ldsfld object Program::_object
L_0007: call void [mscorlib]System.Threading.Monitor::Enter(object)
L_000c: ldc.i4.s 100
L_000e: call void [mscorlib]System.Threading.Thread::Sleep(int32)
L_0013: call int32 [mscorlib]System.Environment::get_TickCount()
L_0018: call void [mscorlib]System.Console::WriteLine(int32)
L_001d: leave.s L_0026
L_0020: call void [mscorlib]System.Threading.Monitor::Exit(object)
.try L_000c to L_001f finally handler L_001f to L_0026
A summary. Lock is a synchronization construct. We looked at an example and stepped into the IL. We related the Theory of Relativity and the complexities of the universe to threading.
© 2007-2020 Sam Allen. Every person is special and unique. Send bug reports to firstname.lastname@example.org.