操作系统——Java线程的多种状态及转换

硌手的小虫子@

已于 2023-09-16 11:07:06 修改

阅读量1.8k

点赞数 1

分类专栏：操作系统文章标签：操作系统

于 2023-03-25 11:22:43 首次发布

本文链接：https://blog.csdn.net/xh1605004242/article/details/129665080

版权

操作系统专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、分类

1、New（创建）

2、Runnable（运行）

3、TIMED_WAITING （超时等待）

1、RUNNABLE与TIMED_WAITING状态转换

（1）、wait()方法转换为TIMED_WAITING状态

（2）、join()方法转换为TIMED_WAITING状态

（3）、sleep()方法转换为TIMED_WAITING状态

2、RUNNABLE与WAITING状态转换

（1）、wait()方法转换为WAITING状态

（2）、join()方法转换为WAITING状态

3、RUNNABLE与BLOCKED状态转换

一、分类

1、New（创建）

Thread t1=new Thread(()->{ });

用Thread类实例化一个对象时便是处于状态。处于 NEW 状态时，系统中的线程还未被创建出来，只是有一个Thread对象，没有调用 Thread 实例的 start() 方法。

2、Runnable（运行）

RUNNABLE状态还可以分成就绪(ready)和运行(running)两个状态的：

就绪状态是指该线程已经做好准备处于等待被cpu调度的状态。
运行状态是指该线程正在被cpu执行

3、TIMED_WAITING （超时等待）

超时等待状态是给线程指定一个具体的等待时间，超过等待时间后会被自动唤醒。

调用sleep()方法时，该线程处于此状态。

public class demo05{
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        Thread.sleep(1000);
        System.out.println(t1.getState());
    }
}

4、Blocked（阻塞）

阻塞状态是指该线程处于BLOCKED状态而其他线程无法运行，在锁的释放后进入同步区，其他线程可以运行。调用synchronized()方法可以使线程处于等待锁状态。

例：t1和t2竞争同一把锁，t1先拿到锁，t2则处于等待锁状态。

public class demo05  {
    public static void main(String[] args) throws InterruptedException {
        Object locker=new Object();
        Thread t1 = new Thread(()->{
            synchronized (locker){
                while(true){

                }
            }
        });
        t1.start();
        Thread.sleep(1000);

        Thread t2 = new Thread(()->{
            synchronized (locker) {

            }
        });
        t2.start();

        System.out.println("t1:"+t1.getState());
        System.out.println("t2:"+t2.getState());
    }
}

5、WAITING （等待）

等待状态是指处于等待状态的线程需要被其他线程唤醒才能变成RUNNABLE 状态继续运行。可以通过调用wait()或join()方法来实现。

（1）、wait()方法

在t1线程中调用wait()方法时，t1变成WAITING状态，直到其他线程通过同一把锁调用notify()方法才能唤醒t1线程变为RUNNABLE状态。

public class demo05{
    public static void main(String[] args) {
        Object locker=new Object();
        Thread t1=new Thread(()-> {
            try {
                synchronized (locker) {
                    locker.wait();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        t1.start();
        Thread.sleep(1000);
        Thread t2=new Thread(()->{
            synchronized (locker){
                System.out.println("notify开始前");
                System.out.println(t1.getState());
                locker.notify();
            }
        });
        t2.start();
    }
}

（2）、join()方法

在t1中调用join()方法使t1等待t2，此时t1就是WAITING状态。

6、TERMINATED（终止）

终止状态是指此时线程已执行完毕。此时调用getState()方法会得到TERMINATED状态。

public class demo05  {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{

        });
        t1.start();
        Thread.sleep(2000);
        System.out.println("t1:"+t1.getState());
    }
}

二、状态切换

1、RUNNABLE与TIMED_WAITING状态转换

（1）、wait()方法转换为TIMED_WAITING状态

t线程用synchronized()方法获取对象锁后：调用wait()方法时，t线程从RUNNABLE状态转换为TIMED_WAITING状态。当等待超过最大时间或者调用notify()方法时t线程从TIMED_WAITING状态重新变为RUNNABLE状态。

（2）、join()方法转换为TIMED_WAITING状态

t线程调用join()方法时，该线程从RUNNABLE状态转化为TIMED_WAITING状态。
当线程等待时间超过最大时间、线程运行结束或调用该线程的 interrupt()方法时，t线程从 TIMED_WAITING状态重新变为RUNNABLE状态。

（3）、sleep()方法转换为TIMED_WAITING状态

t线程调用sleep()方法时，该线程从RUNNABLE状态转变为TIMED_WAITING状态。

当t线程等待时间超过最大时间，t线程从TIMED_WAITING状态重新变为RUNNABLE状态。

2、RUNNABLE与WAITING状态转换

TIMED_WAITING状态与WAITING 状态类似：前者等待的时间是指定的，需要设置时间；后者没有时间限制可以无限等待唤醒。

（1）、wait()方法转换为WAITING状态

t线程用synchronized()方法获取对象锁后：调用wait()方法时，t线程从RUNNABLE状态转换为WAITING状态。当调用notify()方法时t线程从WAITING状态重新变为RUNNABLE状态。

（2）、join()方法转换为WAITING状态

t线程调用join()方法时，该线程从RUNNABLE状态转化为WAITING状态。
当线程运行结束或调用该线程的 interrupt()方法时，t线程从WAITING状态重新变为RUNNABLE状态。

3、RUNNABLE与BLOCKED状态转换

BLOCKED 表示等待获取锁，处于 BLOCKED 状态的线程在等待锁的释放。

假如t1和t2两个线程，t1线程获得锁并且未释放锁，此时t2就处于 BLOCKED 状态。

t线程用 synchronized()方法获取对象锁时如果竞争失败，就从RUNNABLE状态转变为BLOCKED状态。
在获得锁的线程代码块执行完毕后，会唤醒该对象上所有BLOCKED的线程重新竞争，如果其中t线程竞争成功，就从BLOCKED状态重新变为RUNNABLE ，其它失败的线程仍然为BLOCKED状态。