Introduction to C# Thread Synchronization
The technique of the resources being available for only one thread at a time without the interruption of any other thread until the task assigned to the current thread is finished is called synchronization in C#. Actually, any resource can be accessed by the thread for the required amount of time in a multithreading program and the resources are shared and executed asynchronously by the threads which is a critical task and may result in stopping the system and hence threads must be executed synchronously and by synchronization of threads, we can maintain consistency of the threads and make sure no other threads interfere during the execution of one thread.
Syntax of C# Thread Synchronization
Below is the syntax of C#Thread Synchronization is as follows:
Thread thread_name = new Thread(method_name);
thread_name.Start();
thread_name.Join();or
Thread thread_name = new Thread(method_name);
thread_name.Start();
method_name()
{
lock(this)
{
//thread_name thread is executed
}
}Where thread_name is the name of the thread and method_name is the name of the method accessed by this thread alone starting from the time thread_name.Start() is called, and thread_name.Join() waits till the completion of this thread by stopping the execution of all other threads.
Lock keyword within the method, method_name locks the thread execution so that no other threads can access the method until the completion of the current thread.
Functions of C# Thread Synchronization
- Any resource can be accessed by the thread for the required amount of time in a multithreading program but if several threads try to access the same resource, the sharing of resources by several threads at once or asynchronously becomes a critical task and the system may stop the execution.
- To overcome this problem, synchronization of threads is necessary. By synchronization of the thread, only that particular thread can have access to the resource for a certain amount of time without any interruption from the other threads.
- Synchronization of threads can be done using join keyword and lock keyword.
- When join keyword is used on a thread, the thread is allowed to complete its execution without the interruption of any other threads.
- When the lock keyword is used, the resource on which the thread is executing is locked for the time until the thread completes execution.
Examples to Implement C# Thread Synchronization
Below are the examples of C# Thread Synchronization:
Example #1
C# program to demonstrate synchronization of threads using join keyword.
Code:
using System;
using System.Threading;
//a namespace called program is created
namespace program
{
//a class called check is defined
class check
{
//main method is called
static void Main(string[] args)
{
//an instance of the thread class is created which operates on a method
Thread firstthread = new Thread(secondfunction);
//start method is used to begin the execution of the thread
firstthread.Start();
//join method stops all other threads while the current thread is executing
firstthread.Join();
Thread secondthread = new Thread(firstfunction);
secondthread.Start();
secondthread.Join();
}
private static void firstfunction(object obj)
{
for(inti=1;i<3;i++)
{
Console.WriteLine("First function is executed two times in a row because join method is called on the second thread operating on this method.");
}
}
private static void secondfunction(object obj)
{
for(inti=1;i<3;i++)
{
Console.WriteLine("Second function is executed two times in a row because join method is called on the first thread operating on this method.");
}
}
}
}Output:
Explanation: In the above program, a namespace called program is created. Then a class called check is defined within which the main method is called. Then an instance of a thread is created to operate on a method, which is begun using Start() method and join() method is used on the same thread to make sure its execution is not interrupted by the other threads. Hence the output is displayed in a row synchronously. The output of the program is shown in the snapshot above.
Example #2
C# program to demonstrate synchronization of threads using lock keyword.
Code:
using System;
using System.Threading;
//a class called create is created
class create
{
public void func()
{
//lock is called on this method
lock (this)
{
for (inti = 1; i<= 2; i++)
{
Console.WriteLine("The thread is executing");
}
}
}
}
class check
{
public static void Main(string[] args)
{
//an instance of the create class is created
create c = new create();
//an instance of the thread class is created which operates on the method in another class
Thread firstthread = new Thread(c.func);
firstthread.Start();
Thread secondthread = new Thread(c.func);
secondthread.Start();
}
}Output:
Explanation: In the above program, a class called to create is created with which the method is defined for which we have used a lock keyword meaning the thread operating on this method locks the method for itself until it completes execution without allowing other threads to access the method. That way the threads are executed synchronously. The output of the program is shown in the snapshot above.
Conclusion
In this tutorial, we understand the concept of ThreadSynchronization in C# through definition, syntax, and working of Thread synchronization through programming examples and their outputs.
Recommended Article
This is a guide to C# Thread Synchronization. Here we discuss the Introduction to C# Thread Synchronization and its working along with its examples and Code Implementation. You can also go through our other suggested articles to learn more –
