拾遗增补（一）——线程的状态

最新推荐文章于 2024-10-16 10:13:45 发布

Yarrow-Y

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量191

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_44307209/article/details/126851072

版权

线程对象在不同的运行时期有不同的状态，状态信息就存在于State枚举类中。
调用与线程有关的方法是造成线程状态改变的主要原因，使用Java多线程技术，其中线程状态和方法的关系如下图所示：
在这里插入图片描述
线程与状态关系示意图

在调用与线程有关的方法后，会进入不同的次线程状态，这些状态之间某些是可双向切换的，比如 WAITING 和 RUNNING 状态之间可以循环地进行切换；而有些是单向切换的，比如线程销毁后并不能自动进入 RUNNING 状态。

1.验证 NEW、RUNNABLE 和 TERMINATED

下面使用代码的方式验证线程所有的状态值，了解线程的状态有助于程序员监控线程对象所处的情况，比如哪些线程从未启动，哪些线程正在执行，哪些线程正在阻塞，哪些线程正在等待，哪些线程已经销毁了，等等。这些是与线程生命周期相关的信息。
首先验证的是new, runnable及terminated状态，new状态是线程实例化后还从未执行start()方法时的状态，而runnable状态是线程进入运行的状态，terinated是线程被销毁时的状态。

创建名称为7.1.1的项目，类MyThread.java代码如下:

 public class MyThread extends Thread {
    public MyThread() {
        System.out.println("构造方法中的状态：" + Thread.currentThread().getState());
    }
    @Override
    public void run() {
        System.out.println("run方法中的状态:" + Thread.currentThread().getState());
    }
}

类Run.java代码如下：

public class Run {
    //NEW,
    //RUNNABLE,
    //TERMINATED,
    //BLOCKED,
    //WAITING,
    //TIMED_WAITING,
    public static void main(String[] args) {
        try {
            MyThread t = new MyThread();
            System.out.println("main方法中的状态1:" + t.getState());
            Thread.sleep(1000);
            t.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态2:" + t.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

构造方法中的状态：RUNNABLE
main方法中的状态1:NEW
run方法中的状态:RUNNABLE
main方法中的状态2:TERMINATED

2.验证TIMED_WAITING

TIMED_WAITING代表线程执行了Thread.sleep()方法，呈等待状态，等待时间到达，继续向下运行。
创建名称为7.1.2的项目，类MyThread.java代码如下：

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("begin sleep");
            Thread.sleep(10000);
            System.out.println("   end sleep");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

类Run.java代码如下：

public class Run {
    //NEW,
    //RUNNABLE,
    //TERMINATED,
    //BLOCKED,
    //WAITING,
    //TIMED_WAITING,
    public static void main(String[] args) {
        try {
            MyThread t = new MyThread();
            t.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态:" + t.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

程序运行结果如下所示：

begin sleep
main方法中的状态:TIMED_WAITING
   end sleep

执行sleep()方法后线程的状态枚举值就是TIMED_WAITING。

3.验证BLOCKED

BLOCKED状态出现在某一个线程在等待锁的时候。
创建名称为7.1.3的项目，创建业务对象MyService.java代码如下：

public class MyService {
    synchronized static public void serviceMethod() {
        try {
            System.out.println(Thread.currentThread().getName() + "进入了业务方法！");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

类MyThread1.java代码如下：

public class MyThread1 extends Thread {
    @Override
    public void run() {
        MyService.serviceMethod();
    }
}

类MyThread2.java代码如下：

public class MyThread2 extends Thread {
    @Override
    public void run() {
        MyService.serviceMethod();
    }
}

类Run.java代码如下：

public class Run {
    //NEW,
    //RUNNABLE,
    //TERMINATED,
    //BLOCKED,
    //WAITING,
    //TIMED_WAITING,
    public static void main(String[] args) {
            MyThread1 t1 = new MyThread1();
            t1.setName("a");
            t1.start();
            MyThread2 t2 = new MyThread2();
            t2.setName("b");
            t2.start();
            System.out.println("main方法中的t2状态:" + t2.getState());
    }
}

程序运行结果如下所示：

main方法中的t2状态:RUNNABLE
a进入了业务方法！
b进入了业务方法！

从控制台打印的结果来看，t2线程一直在等待t1释放锁，所以t2当时的状态就是BLOCKED。

4.验证WAITING

状态WAITING是线程执行了Object.wait()方法后所处的状态。
创建名称为7.1.4的项目，创建类Lock.java代码如下：

public class Lock {
    public static final Byte lock = new Byte("0");
}

类MyThread.java代码如下：

public class MyThread extends  Thread {
    @Override
    public void run() {
        try {
            synchronized (Lock.lock) {
                Lock.lock.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

类Run.java代码如下：

public class Run {
    //NEW,
    //RUNNABLE,
    //TERMINATED,
    //BLOCKED,
    //WAITING,
    //TIMED_WAITING,
    public static void main(String[] args) {
        try {

        MyThread t = new MyThread();
        t.start();
        Thread.sleep(1000);
        System.out.println("main方法中的t状态:" + t.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}