In the C# programming language, a Thread's life cycle starts when a thread object is created and ends when the thread completes its work or is stopped. A thread passes via multiple states during its lifetime. These different states are very helpful for multithreaded programming. It helps to manage the thread execution and avoid common issues such as deadlocks, race conditions, or unnecessary CPU usage. Several main stages in a thread's life cycle are as follows:
- Unstarted State
- Runnable State
- Running State
- WaitSleepJoin (Not Runnable State)
- Dead State
Here, we will explore the various stages of the thread life cycle in C# step by step.
1) Unstarted State
In C# programming, when a thread is instantiated using the Thread class, it initially resides in the Unstarted state. This indicates that the thread object is created but has not initiated execution. To commence execution, the Start method must be invoked. Upon calling the Start method on the thread object, it transitions out of the Unstarted state to progress to the subsequent state. The Unstarted state is also referred to as the new state.
Syntax:
Here, the syntax of the unstarted state.
Thread t = new Thread(MyMethod); // unstarted state
Upon executing the code Thread t = new(MyMethod); in C#, a fresh instance of a thread is generated to execute the specified method, MyMethod. At this stage, the thread remains inactive, denoting that it is present in the system's memory but has not commenced the execution of any instructions. In this initial phase, the thread is categorized as non-operational and is not deemed to be actively running.
2) Runnable State
In C# programming, the active state signifies a condition where the thread is prepared for processing but awaits CPU allocation for execution. During this phase, the thread is initiated but has not commenced execution yet.
Syntax:
Here, the syntax of the runnable state.
t.Start(); // Thread is now Ready
When we invoke t.Start; on a thread in C#, the thread transitions from the unstarted state to the runnable state or a state where it is prepared to run. During this transition, the thread is prepared to begin execution but remains in a waiting state for the scheduler to choose it for execution. The invocation of the Start method indicates that the thread is prepared to execute the specified method and consequently advances its ThreadState to the subsequent state.
3) Running State
In this condition, a thread transitions to the running state upon invoking the Start method on the thread object. Subsequently, the thread scheduler chooses the thread for code execution. During the running state, the thread carries out its designated code. This operational state is crucial when the thread is actively engaged in its assigned task.
4) WaitSleepJoin State (Not Runnable State)
In this situation, a thread will move into the Not Running State. It means a thread cannot currently run, even though it has been started. It doesn't mean the thread is dead. It is simply waiting for some condition or resource. The thread is ready to execute, but the thread scheduler has not yet selected it to execute. It can happen when:
- The Sleep method is called.
- The thread is waiting for another thread using Wait.
- The thread is blocked due to input/output (I/O) operations.
5) Dead State
Upon completion of its task, a thread transitions to a state known as the dead state or abort state, indicating that the thread's execution has concluded. This marks the final stage in the thread life cycle, reached when the thread finishes its task or is terminated.
C# Example to understand Thread Life Cycle States
Let's consider a scenario to demonstrate the Thread Life Cycle in C#.
Example
using System;
using System.Threading;
namespace C# TutorialThreadState
{
class tech
{
static void Main( string[] args )
{
// Unstarted state
Thread th1 = new Thread(Do);
Console.WriteLine(" Thread not started yet -> Alive? " + th1.IsAlive + ", Current Thread State: " + th1.ThreadState );
// Running state
th1.Start();
Thread.Sleep(100);
Console.WriteLine(" After starting thread: IsAlive = " + th1.IsAlive + ", State = " + th1.ThreadState );
// WaitSleepJoin state
Thread.Sleep(1500);
Console.WriteLine(" While sleeping: IsAlive = " + th1.IsAlive + ", State = " + th1.ThreadState );
// Stopped state
th1.Join();
Console.WriteLine(" After finishing: IsAlive = " + th1.IsAlive + ", State = " + th1.ThreadState );
Console.ReadKey();
}
static void Do()
{
Console.WriteLine(" Thread execution in progress... ");
Thread.Sleep(1000); // Thread goes into WaitSleepJoin state
Console.WriteLine(" Thread finished work. ");
}
}
}
Output:
Thread not started yet -> Alive? False, Current Thread State: Unstarted
Thread execution in progress...
After starting thread: IsAlive = True, State = WaitSleepJoin
Thread finished work.
While sleeping: IsAlive = False, State = Stopped
After finishing: IsAlive = False, State = Stopped
Explanation:
In this instance, we showcase the utilization of the thread life cycle in C#. Initially, we instantiate an object th1 in the unstarted phase, resulting in IsAlive being false. Subsequently, upon invoking the Start function, the thread transitions to the Running stage. Within the Do function, the thread undergoes a 1-second sleep. Upon finishing its execution, the thread concludes and shifts to the Stopped status, causing IsAlive to revert to false. The application displays the thread's state throughout to illustrate this progression.
Features of the Thread Life Cycle in C#
There are several features of the thread life cycle in C#. Some of them are as follows:
- In C#, a thread passes through different states during its lifetime, including Unstarted, Runnable, Running, WaitSleepJoin, and Dead.
- A thread life cycle starts when an object of a thread is created using the System.Threading.Thread class.
- The thread execution is controlled by a thread scheduler that chooses which one of the threads runs at a given time.
- C# enables a thread to run either as foreground or background.
- Thread exceptions should be handled explicitly inside the thread; otherwise, they can cause the thread to terminate unexpectedly.
Conclusion
In summary, the life cycle of a thread depicts the stages of a thread being instantiated, initiated, actively running, temporarily halted, and eventually terminated. This process aids in efficiently handling threads and ensuring the seamless operation of programs. It plays a crucial role in overseeing concurrent tasks, optimizing resource usage, and facilitating multitasking capabilities within applications.
C# Thread Life Cycle FAQs
The primary stages in the life cycle of a C# Thread are as follows:
The main states of the C# Thread Life Cycle are.
- Unstarted State
- Runnable State
- Running State
- Not Runnable State
- Dead State
A thread transitions to the Not Runnable state when it is waiting for a resource or event to become available.
A thread transitions to the Not Runnable state upon initiation but is unable to execute. This occurs when the thread is in a sleeping, waiting, or blocked state due to a resource constraint.
It can happen when:
- The Sleep method is called.
- The thread is waiting for another thread using Wait .
- The thread is blocked due to input/output (I/O) operations.
3) When does a thread enter the Dead state in C#?
When the thread finishes its operation, it transitions into a terminated state. This signifies the completion of the thread's execution, marking the final phase in the thread's life cycle. The thread arrives at this state upon successful completion of its task or due to an abort signal.
4) When does a thread enter the Unstarted state?
When a thread is instantiated using a Thread class, it initially exists in the Unstarted state, indicating that the thread object is created but not yet running. To commence execution, the Start method must be invoked.
5) How does a thread enter the Running state?
In this scenario, a thread transitions to the running state upon invoking the Start function on the thread instance. Subsequently, the thread scheduler chooses the thread for code execution. During the running state, the thread carries out its designated tasks, playing a crucial role in actively executing its assigned operations.
6) What is a thread in C#?
In C#, a thread serves as a lightweight process in a software application, signifying an independent flow of execution. This functionality enables multiple operations to run simultaneously, enhancing system performance through more efficient CPU utilization.