Threading Simplified: Part 9 (Thread Locking)

Prakash Tripathi

10y22.2k22100Article

Multithreading ThreadingThread lockingThreading Overview

22 Comments

Join the conversation! Your thoughts help the community grow.

Prakash Tripathi10y ago
Thnx Ankur.
Ankur Mistry10y ago
Very nice Prakash Tripathi
Prakash Tripathi10y ago
Thnx Sibeesh.
Sibeesh Venu10y ago
Nice Share
Prakash Tripathi10y ago
Thnx Vignesh.
Vignesh Mani10y ago
Good
Prakash Tripathi10y ago
Thnx Ibrahim.
Mohammed Ibrahim10y ago
nice
Prakash Tripathi10y ago
Welcome Sonu.
Sonu Chaudhary10y ago
thanks
Prakash Tripathi10y ago
Thnx Asfend.
Asfend Yar10y ago
nice
Prakash Tripathi10y ago
Thnx Humayun.
Humayun Kabir Mamun10y ago
Nice...
Prakash Tripathi10y ago
Thnx Kumaresh
Prakash Tripathi10y ago
Thnx Karthiga.
Prakash Tripathi10y ago
Thnx Asfend.
Kumaresh Rajalingam10y ago
good one
Kumaresh Rajalingam10y ago
Nice explanation
Sr Karthiga10y ago
god one
Sr Karthiga10y ago
Nice explanation
Asfend Yar10y ago
nice

This article explains what Thread Locking is and how to use it efficiently in multithreading environment.

Before reading this article, I highly recommend reading my previous parts:

Thread Locking, lock keyword

I am again here to continue the discussion around Threading. Today, we will discuss about Thread Locking and related concepts.

Let’s start by putting questions to understand the concepts.

Why Thread Locking?

Locking is used to ensure that only one thread can enter at a time in a code block.

Is Locking Thread Safe by default?

Locking is not thread safe by default and one needs to handle it explicitly to avoid thread clash in a multithreaded environment.

Good so far. Let’s understand it bya simple example.

class TestThreadSafe
{
int num1 = 0;
int num2 = 0;
Random rnd = new Random();
public void DoDivide()
{
for(inti = 0; i < 1000000; i++)
{
num1 = rnd.Next(1, 5);
num2 = rnd.Next(1, 5);
Console.WriteLine(num1 / num2);
num1 = 0;
num2 = 0;
}
}
}
class Program
{
static void Main(string[] args)
{
Console.Title = "Thread Locking Demo";
TestThreadSafe testThreadSafe = new TestThreadSafe();
Threadt1 = new Thread(testThreadSafe.DoDivide);
Threadt2 = new Thread(testThreadSafe.DoDivide);
t1.Start();
t2.Start();
}
}

Output:

error

Hope you realized the problem what’s going wrong here. In case you are still thinking it's not a problem, it’s a one of the concurrency issue that may occur in multithread environment.

If you see the code closely, you can see that at any given instance, thread1 (or t1) may be at LN3 and thread2 (or t2) may be executing LN5. In that case compiler may throw DivideByZeroException.

num1 = rnd.Next(1, 5); //LN1
num2 = rnd.Next(1, 5); //LN2
Console.WriteLine(num1 / num2); //LN3 thread1
num1 = 0; //LN4
num2 = 0;//thread2 //LN5 thread5

So, we understand the problem now, so what’s the solution?

Well,the solution is to handle the concurrency properly. Here we can use lock keyword to address the problem.

Let’s fix the issue by adding a variable and modifying the Do Divide method a little bit as in the following.

class TestThreadSafe
{
private static objectmyLock = newobject();
public void DoDivide()
{
lock(myLock) //This will ensure that only one thread can enter into code.
{
for(inti = 0; i < 1000000; i++)
{
num1 = rnd.Next(1, 5);
num2 = rnd.Next(1, 5);
Console.WriteLine(num1 / num2);
num1 = 0;
num2 = 0;
}
}
}
}

Output:

run

As you can see that exception (DivideByZeroException) which we got in the previous example is not happening anymore as we have enclosed the problematic code within the lock keyword which ensures that only one thread can enter into it.

Note: I have seen some people use as lock(this) that locks the complete class instance which at times may lead to a deadlock situation. So the recommended practice is to have a private static variable created in a class and lock that variable only.

Hope you have liked the article. Look forward for your comments/suggestions.

Read more articles on Multithreading: