二：线程状态流程解析
本文共 13925 字，大约阅读时间需要 46 分钟。
线程一共有哪些状态
线程的状态一共有以下几种：
1）NEW 2）RUNNABLE 3）BLOCKED 4）WAITING 5）TIMED_WAITING 6）TERMINATED 我怎么知道的呢？来来，看一下源码： Thread.class里面：public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; private State() { } } 线程的状态解释和变化
1）New
当new了一个Thread，没有调用他的任何方法，他就处于New状态; 直接上代码：package com.test.main;public class Test { static class MyThread extends Thread{ public MyThread(String name){ super(name); } public void run(){ System.out.println("myThread打印线程名"+Thread.currentThread().getName()); } } public static void main(String[] args) { MyThread thread = new MyThread("myThread"); System.out.println("线程名:"+thread.getName()+",线程状态:"+thread.getState()); }}运行结果：线程名:myThread,线程状态:NEWProcess finished with exit code 0 2）RUNNABLE
当线程调用了start方法，线程如果处于等待操作系统分配CPU资源，等待IO连接，此时处于Ready状态 ，处于已经在运行，那就处于Running状态； 为什么这里有两种呢？因为调用了start，不一定能立马拿到cpu执行时间片，这时候是不太确定的。 我们加上thread.start：package com.test.main;public class Test { static class MyThread extends Thread{ public MyThread(String name){ super(name); } public void run(){ System.out.println("myThread打印线程名"+Thread.currentThread().getName()); } } public static void main(String[] args) { MyThread thread = new MyThread("myThread"); thread.start(); System.out.println("线程名:"+thread.getName()+",线程状态:"+thread.getState()); }}运行结果:线程名:myThread,线程状态:RUNNABLE 3）BLOCKED
当线程尝试拿锁，但是锁一直被占用，线程这时候会被操作系统挂起，这是被称为线程阻塞； 实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 Thread t1 = new Thread(new Runnable() { public void run() { synchronized(sdf){ while (true){ } } } }); t1.setName("线程1"); t1.start(); Thread.sleep(1000); //线程2 Thread t2 = new Thread(new Runnable() { public void run() { synchronized (sdf){ System.out.println("线程2拿锁打印当前日期:"+sdf.format(new Date())); } } }); t2.setName("线程2"); t2.start(); System.out.println("线程1状态:"+t1.getState()); System.out.println("线程2状态:"+t2.getState()); RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); String pidStr = runtimeMXBean.getName(); System.out.println("pidStr="+pidStr); int pid = Integer.parseInt(pidStr.split("@")[0]); System.out.println("当前程序的进程号pid="+pid); }}运行结果：线程1状态:RUNNABLE线程2状态:BLOCKEDpidStr=11548@C01-16120305-01当前程序的进程号pid=11548说明：线程1因为在synchronized里面死循环，那么对象sdf无法被释放锁，一直被线程1锁持有，所以Thread2永远也拿不到对象sdf资源，线程被阻塞，也就是BLOCKED；我们打印出来了该main进程的pid，为11548，接下来，我们用jstack -l 11548看一下堆栈日志。 打开idea下方的Terminal：
E:\mytestProject\springtest>jstack -l 115482020-10-14 14:10:22Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.71-b01 mixed mode):"DestroyJavaVM" prio=6 tid=0x0000000003652800 nid=0x2cc4 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE Locked ownable synchronizers: - None"线程2" prio=6 tid=0x00000000122f4000 nid=0x1c18 waiting for monitor entry [0x0000000013d7f000] java.lang.Thread.State: BLOCKED (on object monitor) at com.test.main.Test$2.run(Test.java:37) - waiting to lock <0x00000007ab8447a8> (a java.text.SimpleDateFormat) at java.lang.Thread.run(Thread.java:745) Locked ownable synchronizers: - None"线程1" prio=6 tid=0x00000000122f1000 nid=0x2fb8 runnable [0x0000000013c7f000] java.lang.Thread.State: RUNNABLE at com.test.main.Test$1.run(Test.java:22) - locked <0x00000007ab8447a8> (a java.text.SimpleDateFormat) at java.lang.Thread.run(Thread.java:745) Locked ownable synchronizers: - None说明：我们可以看到线程2的状态为:java.lang.Thread.State: BLOCKED (on object monitor)线程2处于等待拿锁：waiting to lock，锁对象为：java.text.SimpleDateFormat线程1的状态为：java.lang.Thread.State: RUNNABLE线程1处于上锁状态：locked，锁对象为：java.text.SimpleDateFormat
4）WAITING
从单词上来看，他是等待的意思，这里指的是没有超时的等待，简单的说，如果一个线程处于该WAITING状态，没有被唤醒或者他等待的线程没有结束，他会一直拿不到cpu资源和锁。他跟BOLCKED的区别就是：BLOCKED他只有拿到锁才会继续运行，但是WAITING可以主动唤醒或者他等待的线程运行结束之后，它就可以接着运行。 使线程进入WAITING状态的3个方法： 1.调用wait()方法 调用wait方法所在的线程进入等待，只能在synchronized块中使用，可以被synchronized锁住的对象锁唤醒。 实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { synchronized (sdf) { try { System.out.println("线程1-wait准备wait,当前线程状态为:" + this.getState()); sdf.wait(); System.out.println("线程1-wait结束,当前线程状态为:" + this.getState()); } catch (Exception e) { e.printStackTrace(); } } } }; //线程1 Thread t2 = new Thread("线程2") { public void run() { synchronized (sdf) { System.out.println("线程1的此时的状态:"+t1.getState()); System.out.println("线程2-准备唤醒,当前线程状态为:" + this.getState()); sdf.notify(); System.out.println("线程2-唤醒结束,当前线程状态为:" + this.getState()); System.out.println("线程1的此时的状态:"+t1.getState()); } } }; t1.start(); t2.start(); RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); System.out.println(runtimeMXBean.getName().split("@")[0]); }}运行结果：线程1-wait准备wait,当前线程状态为:RUNNABLE线程1的此时的状态:WAITING线程2-准备唤醒,当前线程状态为:RUNNABLE线程2-唤醒结束,当前线程状态为:RUNNABLE线程1的此时的状态:BLOCKED线程1-wait结束,当前线程状态为:RUNNABLE结果分析：第一步：线程1进入synchronized块，拿到日期sdf对象的持有锁，然后调用sdf对象的wait方法，使当前线程也就是线程1进入WAITING状态，也就释放了sdf对象的持有锁（此时线程2处于BLOCKED状态，别问我怎么知道，不信你看BLOCKED篇）第二步：线程2拿到了sdf对象的持有锁，此时线程1依然处于WAITING状态，接着调用了sdf对象的notify方法，就会唤醒所有持有sdf对象锁的线程去重新拿锁（这里会唤醒线程1去尝试重新拿sdf的锁），但是发现sdf对象的锁现在依然还是被线程2持有，所以此时线程1已经进入阻塞状态BLOCKED第三部：线程持有sdf对象锁代码块继续执行，执行完成后，释放sdf对象锁，然后线程1从阻塞状态重新拿到刚刚释放的sdf对象锁，然后接着执行一开始没有执行的代码： System.out.println("线程1-wait结束,当前线程状态为:" + this.getState()); 2.join()方法
线程如果调用了join方法，那么代表这个调用者进入阻塞执行，只有当这个调用者所在的线程执行完毕之后，才能接着执行下一个线程； 实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { for (int i = 0 ;i < 100; i++){ System.out.println("线程1打印1到100,当前:"+i); } } }; //线程1 Thread t2 = new Thread("线程2") { public void run() { for (int i = 0 ;i < 20; i++){ System.out.println("线程2打印1到100,当前:"+i); } } }; t1.start(); t1.join(); t2.start(); t2.join(); for (int i = 0 ;i < 30; i++){ System.out.println("main线程打印1到100,当前:"+i); } }} 运行结果，按照线程1，2，main的顺序执行：
3.LockSupport.park() 使park方法被调用所在的线程进入WAITING状态，也就是先不执行他了，先去执行别的线程; 先来一段代码： package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.LockSupport;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { System.out.println("111"); LockSupport.park(); System.out.println("222"); } }; t1.start(); Thread.sleep(1000); System.out.println("main111"); System.out.println("线程1的状态:"+t1.getState()); System.out.println("main222"); }}运行结果：111main111线程1的状态:WAITINGmain222说明：1：先执行park之前2：线程1进入WAITING3：执行main的3个打印4：由于线程1没有被唤醒，所有没有后续日志 5）TIMED_WAITING
这个跟上文的WAITING类似，只不过多了一个时间参数，被称为超时等待。除了wait,join和park之外，还有sleep方法也能进入该状态； 1.wait(超时) 实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.LockSupport;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { synchronized (this){ System.out.println("线程1进入wait前,状态为:"+this.getState()); try { long start = System.currentTimeMillis(); this.wait(10000); long ss = System.currentTimeMillis()-start; System.out.println("线程1结束wait状态为"+this.getState()+",共耗时"+ss+"ms"); } catch (InterruptedException e) { e.printStackTrace(); } } } }; t1.start(); Thread.sleep(1000); System.out.println("main111"); System.out.println("线程1进入wait之后的状态:"+t1.getState()); System.out.println("main222"); }}运行结果:线程1进入wait前,状态为:RUNNABLEmain111线程1进入wait之后的状态:TIMED_WAITINGmain222线程1结束wait状态为RUNNABLE,共耗时10000ms说明：1：线程1进入synchronized代码开，打印wait之前的状态为RUNNABLE2：线程1调用wait(10000)，等待10秒钟3：主线程开始执行，打印main1114：主线程打印此时线程1的状态为：TIMED_WATTING5：主线程打印main2226：10秒钟之后，线程1自动唤醒，重新拿到自身对象锁，当前状态恢复成RUNNABLE，打印wait之后，耗时刚好就是10秒 再来看看join超时
2.join(带超时)
实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.LockSupport;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { for (int i = 0; i < 10; i++) { System.out.println("run()中的i="+i); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; t1.start(); Thread.sleep(1000); System.out.println("main开始运行"); System.out.println("准备调用线程1的join方法，阻塞main线程3秒钟"); t1.join(3000); for (int i = 0; i < 5; i++) { System.out.println("main中的i="+i); } }}运行结果：run()中的i=0main开始运行准备调用线程1的join方法，阻塞main线程3秒钟run()中的i=1run()中的i=2run()中的i=3main中的i=0main中的i=1main中的i=2main中的i=3main中的i=4run()中的i=4run()中的i=5run()中的i=6run()中的i=7run()中的i=8run()中的i=9说明：1：线程1开始打印第一个数字0，睡眠1秒2：main开始执行，执行到调用线程1的join方法，开始阻塞main线程执行，main此时状态为TIMED_WAITING3：3秒之后，main线程被唤醒，线程1进行睡眠1秒，开始打印main线程的i4：接着打印线程1剩下的i 6）TERMINATED
一般执行完了线程的run方法之后，线程状态表示结束； 实例代码：package com.test.main;import sun.java2d.pipe.SpanShapeRenderer;import javax.net.ssl.ManagerFactoryParameters;import javax.sound.midi.Soundbank;import java.lang.management.ManagementFactory;import java.lang.management.RuntimeMXBean;import java.text.SimpleDateFormat;import java.util.Date;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.LockSupport;public class Test { private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public static void main(String[] args) throws InterruptedException { //线程1 final Thread t1 = new Thread("线程1") { public void run() { System.out.println("线程1执行了run方法"); } }; t1.start(); Thread.sleep(1000); t1.join(); System.out.println("main线程开始执行..."); System.out.println("线程1执行run之后的状态为:"+t1.getState()); }}运行结果：线程1执行了run方法main线程开始执行...线程1执行run之后的状态为:TERMINATED说明：1：线程1开始阻塞执行，打印,线程1执行了run方法2：阻塞结束，main开始执行，此时线程1的状态为：TERMINATED 针对以上，来一张状态流程图：
下一篇： 转载地址：http://iikmi.baihongyu.com/
你可能感兴趣的文章
【心灵鸡汤】Give it five minutes不要让一个好主意随风而去
查看>>
【React Native】Invariant Violation: Application AwesomeProject has not been registered
查看>>
【ReactNative】真机上无法调试 could not connect to development server
查看>>
【XCode 4.6】常用快捷键 特别是格式化代码ctrl+i
查看>>
【iOS游戏开发】icon那点事 之 实际应用(二)
查看>>
【iOS游戏开发】icon那点事 之 图标设计(三)
查看>>
【IOS游戏开发】之测试发布(Distribution)
查看>>
【IOS游戏开发】之IPA破解原理
查看>>
【一天一道LeetCode】#45. Jump Game II
查看>>
【一天一道LeetCode】#46. Permutations
查看>>
【一天一道LeetCode】#47. Permutations II
查看>>
【一天一道LeetCode】#56. Merge Intervals
查看>>
【一天一道LeetCode】#58. Length of Last Word
查看>>
【一天一道LeetCode】#59. Spiral Matrix II
查看>>
【一天一道LeetCode】#30. Substring with Concatenation of All Words
查看>>
【一天一道LeetCode】#60. Permutation Sequence.
查看>>
【一天一道LeetCode】#113. Path Sum II
查看>>
【一天一道LeetCode】#114. Flatten Binary Tree to Linked List
查看>>
【unix网络编程第三版】阅读笔记（二）：套接字编程简介
查看>>
【一天一道LeetCode】#115. Distinct Subsequences
查看>>