编程知识 cdmana.com

Java thread state and switch

Java Thread state and switch

One 、 What is? Java Thread state

stay Java In the program , Used to describe Java Six states of thread :

  • newly build (NEW): Current thread , It's just been built , Not yet started .
  • function (RUNNABLE): Current thread , In competition CPU Time sliced or acquired CPU The state of the time slice .
  • wait for (WAITTING): Current thread , In dormancy , No participation CPU The state of time slice competition .
  • Wait regularly (TIMED_WAITTING): Current thread , In a timed sleep , Don't take part in CPU The state of time slice competition .
  • Blocking (BLOCKED): Current thread , It's in a jam , No participation CPU The state of time slice competition .
  • End (TERMINATED): Current thread , In a state of final cessation .

New state , Can only enter the running state . The termination state cannot be changed to any other state .

wait for / Timed waiting and blocking , The difference is that the latter requires an event signal ( If other threads abandon the exclusive lock required by the current thread ), Before you can switch state . Of course , It's OK to force closure .

Java Thread implementation is not subject to JVM Normative constraints , So the implementation of different virtual machines , It's often different . At present, the mainstream HotSpot It's going to be every Java Threads are mapped directly to native threads of an operating system , Thus, the operating system completes a series of thread scheduling

Two 、 Where to see Java Thread state

see Java Thread state , There are three main ways :

  • java.lang.Thread.State You can directly see Java Six thread states of
  • Java Runtime , Inside the program, you can use Thread.getState() Get target thread status
  • Java Runtime , Outside the program, you can use jstack Tools such as , View thread status

of jstack Wait for tools to use , There will be blogs later , To elaborate on .

3、 ... and 、 When to change Java Thread state

Java Thread state switching . No verbosity , Directly above .
 Insert picture description here
This picture covers Java Various methods of thread state switching . Compared with some pictures on the Internet , More detailed .
If something is missing , Can tell me , I'll fill it in time .

Four 、 Who is using Java Thread state

Daily development , We don't interact directly with thread state .
We often use JDK Packaged tools , Such as JUC All kinds of tools under the bag .

Take a chestnut

Application in thread pool

Location :com.sun.corba.se.impl.orbutil.threadpool.ThreadPoolImpl#close

 // Note that this method should not return until AFTER all threads have died. public void close() throws IOException {  // Copy to avoid concurrent modification problems.  List<WorkerThread> copy = null;  synchronized (workersLock) {   copy = new ArrayList<>(workers);  }  for (WorkerThread wt : copy) {   wt.close();   while (wt.getState() != Thread.State.TERMINATED) {    try {     wt.join();    } catch (InterruptedException exc) {     wrapper.interruptedJoinCallWhileClosingThreadPool(exc, wt, this);    }   }  }  threadGroup = null; }

Actually check JDK After the discovery ,JDK In fact, there are not so many examples of spicy , And most of them are directly related to the thread state , It's also something about status checking .
This is said at the beginning of the article ,Java Thread operation , It's very low-level , Even the implementation is not included in the virtual machine specification .
Mainstream HotSpot, It's also a direct way to Java Threads map to system threads , By the system to carry out a series of thread scheduling processing .
therefore , stay JDK in , There is little direct processing of the state of the thread .

5、 ... and 、 Why thread state is needed

1. Why the concept of thread state is needed

This problem , It can be explained from two aspects : Life cycle and resource management

  • One side , Thread state is a good description of the whole life cycle of a thread , The different stages in the life cycle are divided effectively .
  • On the other hand , Resources are limited , The demand is infinite . So we need to schedule the system resources consciously , Make rational use of comparative advantages , The pursuit of Pareto optimality .

Realize the latter , It is the use of thread in the different stages of the life cycle of this natural attribute of the description of state , The grouping that was carried out .CPU Scheduling only needs to focus on the running state of the thread . And jam , Wait for threads , They all have their own way of handling . Finally get the resources ( Development response to complexity , The runtime consumes system resources , The growth of the user's mental model, etc ) The optimal allocation of .

2.JDK Why do we need to define Java Thread state

I said before ,Java Thread state is rarely used directly in . So why are you still in JDK In the definition of Java The six thread states of ?
One side , Through information transparency , Reduce the cost of building mental models for users . Such as , Now we can print logs , Breaking point , Quickly understand Java State of each thread of , And have a clear understanding of the causes . This greatly improves our understanding of Java Understanding of threads , And embrace more happily JUC Package, such as thread pool and other tools .
On the other hand , By enumerating states that can be applied directly , We can make a good secondary development of the existing tools . For example, we can expand AQS, And add the verification of thread state in it , So we can get a customized thread synchronization tool .

6、 ... and 、 How to use thread state

How to use it , I've already said that : Study Java Threads , Custom thread related tool development .
Here is an example of thread learning demo:

/** * @program: learning * @description:  Used to confirm thread status problems  * @author: Jarry * @create: 2020-10-26 22:25 **/public class ThreadState { public static void main(String[] args) {  threadStateTest();//  threadStateTest2();//  threadStateWithBlocked();//  threadStateWithException();//  threadStateWithSuspend(); } /**  *  Practice has proved :Thread.suspend() And Thread.resume() Does not change the thread state   *  The thread state should be Waiting, Just Waiting. The Timed_Waiting Just Timed_Waiting  * Thread.suspend() And Thread.resume() Just suspend the target thread ( And does not release lock resources )  */ private static void threadStateWithSuspend() {  Thread thread1 = new Thread(() -> {//   LockSupport.park();   LockSupport.parkNanos(2000000000);  });  thread1.start();  printThreadState(thread1);  LockSupport.parkNanos(500000000);  printThreadState(thread1);  thread1.suspend();  printThreadState(thread1);  LockSupport.parkNanos(500000000);  printThreadState(thread1);  thread1.resume();  LockSupport.parkNanos(500000000);  printThreadState(thread1);//  LockSupport.unpark(thread1); } /**  *  Show thread blocking status   */ private static void threadStateWithBlocked() {  Runnable runnable = new Runnable() {   @Override   public void run() {    synchronized (ThreadState.class) {//     LockSupport.parkNanos(2000000000);     LockSupport.park();    }   }  };  Thread thread1 = new Thread(runnable);  Thread thread2 = new Thread(runnable);  thread1.start();  LockSupport.parkNanos(500000000);  thread2.start();  //  Add the following intervals , Then the result :Runnable->Blocked  //  inference :Thread.start() The thread state is set to Runnable, And then I met sync Lock of , Then switch to Blocked state //  LockSupport.parkNanos(500000000);  printThreadState(thread2);  LockSupport.parkNanos(500000000);  printThreadState(thread2);  LockSupport.parkNanos(500000000);  LockSupport.unpark(thread1);  LockSupport.unpark(thread2); } /**  *  from .........

版权声明
本文为[Irving the procedural ape]所创,转载请带上原文链接,感谢

Scroll to Top