Java Essentials - Life cycle of a thread | Java

In this video we are discussing a very important concept that is the life cycle of a thread

We shall explain this concept with one diagram. So here is a diagram we are getting

Here we are finding that we are having certain states that there is a new, runable, waiting

timed waiting, terminated and blocked. This terminated state can also be called as a dead state

So whenever a new thread will be originated, then it will be. be found in the new state also known as the born state

Now when the thread will start its execution, then it will be found in this runable state

And in this runable state, the thread is supposed to perform its task

There is an intended task to be performed which will be executed when the thread will

be found in the runable state. When the trade will be found in the runable state, the thread may get suspended due to the

presence of some higher priority threat in the system so it will be found in the

waiting state through this weight and when that respective constraint will be

waived then through notify or notify all that state transition will take place for the thread from moving from this waiting state to this runable state Sometimes this waiting may be for a certain duration only

In that case, the thread will be found in the timed waiting and then there is a wait or slip

So using this, the thread will have the timed waiting. That means the thread will not be waiting at this particular state for indefinite period of time

but it will be waiting here for certain duration only. So when the interval expires through notify or notify all, this timed waiting state

to this runable state, the state transition will take place. And when this runable state, when the thread will be found and after its completion

of its task, then the task completes will take place and it will be found in the terminated

state or the dead state and the thread will be, will be able to be. expiring here now due to some I.O request a thread might be found in the block state or

enter synchronized statement the thread might be found in the block state and when this this acquired

lock interrupt or when the IO completion will be obtained then the thread will be found in the runable state back again so let us go for this respective states into more declaration and with a more definition in the next slide

What is the life cycle of a thread? A thread goes through various stages in its life cycle

The different states are new, runable, running, running, waiting and terminated. At first way, discussing

this new. A new thread begins its lifecycle in the new state and it remains in this state

until the program starts the thread and it is also referred to as the bond thread

Next one is the runable. So after a newly born trade is started, the thread becomes runnable

and the thread in this state is considered to be executing the respective task what was

supposed to get executed by this thread. So in the runnable state, actually, the thread is

executing its own task. Next one, we are having this waiting. Sometimes a threat transitions

to the waiting state while the thread waits for another thread to perform a certain task So some higher priority thread may come into the system So this particular thread may be found having a transition from the runable state to the waiting state

A threat conditions back to the runable state only when another threat signals the waiting

thread to continue its execution. Next one is the timed waiting. A runable thread can enter the time waiting state for a specified interval of time

A thread in this state transitions back to the runnable state when the time interval expires

or when the event it is waiting for occurs. So whenever the time will expire or the event for which it is waiting, when it will occur

then it will go back to the runable state back again from the timed waiting state

Next one is the terminated, also known as the dead state. A runable thread enters the terminated state when it completes its task or other

otherwise terminates. So that is a terminated state or dead state. So we have explained all this concept using the diagram also

Now we are discussing priorities of a thread. Every Java thread has a priority that helps that operating system determine the order in which