二：线程状态流程解析

最新推荐文章于 2021-01-13 19:59:26 发布

惜白丶

最新推荐文章于 2021-01-13 19:59:26 发布

阅读量237

点赞数

分类专栏：多线程笔记

本文链接：https://blog.csdn.net/tianhong2015/article/details/109069261

版权

多线程笔记专栏收录该内容

6 篇文章 1 订阅

订阅专栏

线程一共有哪些状态

线程的状态一共有以下几种：
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,线程状态:NEW
Process 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状态:BLOCKED
pidStr=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 11548
2020-10-14 14:10:22
Full 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");

    }
}
运行结果：
111
main111
线程1的状态:WAITING
main222

说明：
1：先执行park之前
2：线程1进入WAITING
3：执行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前,状态为:RUNNABLE
main111
线程1进入wait之后的状态:TIMED_WAITING
main222
线程1结束wait状态为RUNNABLE,共耗时10000ms

说明：
1：线程1进入synchronized代码开，打印wait之前的状态为RUNNABLE
2：线程1调用wait(10000)，等待10秒钟
3：主线程开始执行，打印main111
4：主线程打印此时线程1的状态为：TIMED_WATTING
5：主线程打印main222
6：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=0
main开始运行
准备调用线程1的join方法，阻塞main线程3秒钟
run()中的i=1
run()中的i=2
run()中的i=3
main中的i=0
main中的i=1
main中的i=2
main中的i=3
main中的i=4
run()中的i=4
run()中的i=5
run()中的i=6
run()中的i=7
run()中的i=8
run()中的i=9

说明：
1：线程1开始打印第一个数字0，睡眠1秒
2：main开始执行，执行到调用线程1的join方法，开始阻塞main线程执行，main此时状态为TIMED_WAITING
3：3秒之后，main线程被唤醒，线程1进行睡眠1秒，开始打印main线程的i
4：接着打印线程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

针对以上，来一张状态流程图：
在这里插入图片描述
下一篇：线程池类关系和参数解析

惜白丶

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
二：线程状态流程解析

线程一共有哪些状态线程的状态一共有以下几种：1）NEW2）RUNNABLE3）BLOCKED4）WAITING5）TIMED_WAITING6）TERMINATED我怎么知道的呢？来来，看一下源码：Thread.class里面：public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATE
复制链接

扫一扫