当前位置：网站首页>Interview must ask | what stages does a thread go through from creation to extinction?

Interview must ask | what stages does a thread go through from creation to extinction?

2022-07-27 04:34:00 【glacier】

Hello everyone , I'm glacier ~~

stay 【 Proficient in high concurrency series 】 Medium 《 High concurrency —— Thread and multithreading 》 In the article , We briefly introduced the life cycle of threads and several important states of threads , And how the thread enters each state is implemented in the form of code .

today , Let's combine Operating system threads and programming language threads Once again, we will explore the life cycle of threads , The life cycle of threads is not as simple as we think ！！

Understanding the life cycle of threads essentially understands The state transition mechanism of each node in the life cycle That's all right. . Next , Let's separate Common thread life cycle and Java Thread life cycle of language Explain in detail .

Common thread life cycle

The general thread life cycle can be divided into five states ： The initial state 、 Operational state 、 Running state 、 Sleep state and termination state .

We can simply use the figure below to represent these five states .

The initial state

The thread has been created , But it is not allowed to allocate CPU perform . It should be noted that ： This state is specific to the programming language , The thread referred to here has been created , Only refers to being created in a programming language , In the operating system , No real threads were created .

Operational state

Threads can be allocated CPU perform . here , The thread in the operating system was successfully created , Can allocate CPU perform .

Running state

When there are idle in the operating system CPU, The operating system will put this idle CPU Assigned to a thread that is in a runnable state , Be assigned to CPU The state of the thread changes to the running state

Sleep state

A running thread invokes a blocked API（ for example , Read the file in a blocked way ） Or wait for an event （ for example , Wait for a conditional variable, etc ）, The state of the thread will change to sleep state .** The thread is released CPU resources , A dormant thread has no chance to get CPU Right to use .** Once the waiting condition occurs , The thread will transition from sleep to runnable .

Termination status

The thread will enter the termination state after the execution is completed or an exception occurs , A thread in the terminated state does not switch to any other state , It also means that The thread's life cycle is over .

The above is the general thread life cycle , below , Let's look at the comparison Java Thread life cycle in language .

Java Thread life cycle in

Java The thread life cycle in can be divided into six states ： Initialization status （NEW）、 Can run / Running state （RUNNABLE）、 Blocked state （BLOCKED）、 No time limit waiting state （WAITING）、 Time limited waiting state （TIMED_WAITING）、 Termination status （TERMINATED）.

What we need to understand is ： although Java There are many thread states in the language , however , In fact, at the operating system level ,Java Blocking state in thread （BLOCKED）、 No time limit waiting state （WAITING）、 Time limited waiting state （TIMED_WAITING） It's all a state , That is, the sleep state in the general thread life cycle . in other words , as long as Java When the thread in is in these three states , that , This thread has no CPU Right to use .

After understanding these , We can use the following diagram to simply represent Java The life cycle of threads in .

We can also understand the blocking state in this way （BLOCKED）、 No time limit waiting state （WAITING）、 Time limited waiting state （TIMED_WAITING）, They are the three causes of thread hibernation ！

Next , Let's just see Java How the state in the thread is transformed .

RUNNABLE And BLOCKED State transition

Only one scenario triggers this transformation , It's just thread waiting synchronized Implicit lock .synchronized The method of decoration 、 Only one thread is allowed to execute the code block at the same time , Other threads need to wait .

here , The waiting thread will start from RUNNABLE State transition to BLOCKED state . When the waiting thread gets synchronized When implicitly locked , I'll go from BLOCKED State transition to RUNNABLE state .

here , I need your attention ： Thread call blocking API when , At the operating system level , The thread will transition to sleep . But in JVM in ,Java The state of the thread does not change , in other words ,Java The state of the thread is still RUNNABLE state .

JVM Does not care about operating system scheduling related states , stay JVM Point of view , wait for CPU Right to use （ Threads in the operating system are in an executable state ） And wait for IO operation （ Threads in the operating system are dormant ） There is no difference between , Are waiting for a certain resource , therefore , Put them all under RUNNABLE state .

What we usually say Java In call blocking API when , The thread will block , Refers to the state of the operating system thread , Not at all Java State of thread .

RUNNABLE And WAITING State transition

The thread from RUNNABLE The state changes to WAITING There are three scenarios for states in general .

Scene one

get synchronized Thread of implicit lock , Call parameterless Object.wait() Method . At this point, the thread will start from RUNNABLE The state changes to WAITING state .

Scene two

Call parameterless Thread.join() Method . among join() Method is a thread synchronization method . for example , stay threadA Call in thread threadB Thread join() Method , be threadA Thread will wait threadB The thread is finished .

and threadA The thread is waiting threadB During thread execution , Its state will change from RUNNABLE The switch to WAITING. When threadB completion of enforcement ,threadA The state of the thread will change from WAITING The state changes to RUNNABLE state .

Scene three

call LockSupport.park() Method , The current thread will block , The state of the thread will change from RUNNABLE convert to WAITING.

call LockSupport.unpark(Thread thread) Wake up target thread , The state of the target thread will change from WAITING State transition to RUNNABLE.

RUNNABLE And TIMED_WAITING State transition

In general, it can be divided into five scenarios .

Scene one

Call... With timeout parameter Thread.sleep(long millis) Method ;

Scene two

get synchronized Thread of implicit lock , Call... With timeout parameter Object.wait(long timeout) Parameters ;

Scene three

Call... With timeout parameter Thread.join(long millis) Method ;

Scene 4

Call... With timeout parameter LockSupport.parkNanos(Object blocker, long deadline) Method ;

Scene five

Call... With timeout parameter LockSuppor.parkUntil(long deadline) Method .

from NEW To RUNNABLE state

Java Just created Thread Object is NEW state , establish Thread There are two main ways to target , One is inheritance Thread object , rewrite run() Method ; The other is to realize Runnable Interface , rewrite run() Method .

Be careful ： This is about creating Thread Object method , Instead of creating a thread , The method of creating a thread includes creating Thread Object method .

Inherit Thread object

public class ChildThread extends Thread{
    
    @Override
    public void run(){
    
        // The logic that needs to be executed in the thread 
    }
}
// Creating thread objects 
ChildThread childThread = new ChildThread();

Realization Runnable Interface

public class ChildRunnable implements Runnable{
    
    @Override
    public void run(){
    
        // The logic that needs to be executed in the thread 
    }
}
// Creating thread objects 
Thread childThread = new Thread(new ChildRunnable());

be in NEW Threads in state are not scheduled by the operating system , Therefore, it will not execute .Java The thread in the should execute , You need to switch to RUNNABLE state . from NEW State transition to RUNNABLE state , You only need to call the thread object start() The method can .

// Creating thread objects 
Thread childThread = new Thread(new ChildRunnable());
// call start() Method to make the thread from NEW State transition to RUNNABLE state 
childThread.start();

RUNNABLE To TERMINATED state

The thread is finished run() After the method , Or perform run() Method , Will end , This is the case TERMINATED state . If we need to interrupt run() Method , You can call interrupt() Method .

Okay , That's all for today , I'm glacier , See you next time ~~

At the end

If you want to enter a large factory , I want a promotion and a raise , Or I'm confused about my current job , You can communicate with me by private letter , I hope some of my experiences can help you ~~

Recommended reading ：

Okay , That's all for today , Like it, guys 、 Collection 、 Comment on , Get up with one button three times in a row , I'm glacier , See you next time ~~

原网站

版权声明
本文为[glacier]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/208/202207262258355733.html