线程的生命周期指的是线程从创建到销毁的整个过程,通常情况下线程的生命周期有以下 5 种:

初始状态
可运行状态
运行状态
休眠状态
终止状态
它们的状态转换如下图所示:

Java 线程生命周期
Java 线程的生命周期和上面说的生命周期是不同的,它有以下 6 种状态:

NEW(初始化状态)
RUNNABLE(可运行/运行状态)
BLOCKED(阻塞状态)
WAITING(无时限等待状态)
TIMED_WAITING(有时限等待状态)
TERMINATED(终止状态)
我们可以在 Thread 的源码中可以找到这 6 种状态,如下所示:

当然你也可以使用 Java 代码,来打印所有的线程状态,如下代码所示:

for (Thread.State value : Thread.State.values()) {
    System.out.println(value);
}
复制代码

以上程序的执行结果如下图所示:

生命周期转换
接下来我们聊聊 Java 线程生命周期的转换过程。

1.从 NEW 到 RUNNABLE
当我们创建一个线程的时候,也就是 new Thread 的时候,此时线程是 NEW 状态,如下代码所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // ...
    }
});
// 获取线程状态
Thread.State state = thread.getState();
System.out.println(state);
复制代码

以上程序的执行结果如下图所示:

然而调用了线程的 start 方法之后,线程的状态就从 NEW 变成了 RUNNABLE,如下代码所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 获取到当前执行的线程
        Thread currThread = Thread.currentThread();
        // 获取线程状态
        Thread.State state = currThread.getState();
        // 打印线程状态
        System.out.println(state);
    }
});
thread.start()

;
复制代码
以上程序的执行结果如下图所示:

2.从 RUNNABLE 到 BLOCKED
当线程中的代码排队执行 synchronized 时,线程就会从 RUNNABLE 状态变为 BLOCKED 阻塞状态,如下代码所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            // 等待 100 毫秒
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("排队使用锁");
        synchronized (ThreadStates.class) {
        }
    }
});
thread.start();
// 让主线程先得到锁
synchronized (ThreadStates.class) {
    // 获取线程状态
    Thread.State state = thread.getState();
    // 打印线程状态
    System.out.println("首次获取线程状态:" + state);
    // 休眠 1s
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 再次获取线程状态
    state = thread.getState();
    // 打印线程状态
    System.out.println("第二次获取线程状态:" + state);
}
复制代码

以上程序的执行结果如下图所示:

当线程获取到 synchronized 锁之后,就会从 BLOCKED 状态转变为 RUNNABLE 状态。

3.从 RUNNABLE 到 WAITTING
线程调用 wait() 方法之后,就会从 RUNNABLE 状态变为 WAITING 无时限等待状态,如下所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (this) {
            try {
                // 线程休眠
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态:" + state);
// 休眠 1s
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态:" + state);
复制代码

以上程序的执行结果如下图所示:

当调用了 notify/notifyAll 方法之后,线程会从 WAITING 状态变成 RUNNABLE 状态,如下代码所示:

Object lock = new Object();
// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                // 线程休眠
                lock.wait();
                // 获取当前线程状态
                Thread.State state = Thread.currentThread().getState();
                // 打印线程状态
                System.out.println("获取线程状态:" + state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态:" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态:" + state);

// 唤醒 thread 线程
synchronized (lock) {
    lock.notify();
}
复制代码

以上程序的执行结果如下图所示:

4.从 RUNNABLE 到 TIMED_WATTING
当调用带超时时间的等待方法时,如 sleep(xxx),线程会从 RUNNABLE 状态变成 TIMED_WAITING 有时限状态,如下代码所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态:" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态:" + state);
复制代码

以上程序的执行结果如下图所示:

当超过了超时时间之后,线程就会从 TIMED_WAITING 状态变成 RUNNABLE 状态,实现代码如下:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            // 获取当前线程状态
            Thread.State state = Thread.currentThread().getState();
            // 打印线程状态
            System.out.println("获取线程状态:" + state);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态:" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态:" + state);
复制代码

以上程序的执行结果如下图所示:

5.RUNNABLE 到 TERMINATED
线程执行完之后,就会从 RUNNABLE 状态变成 TERMINATED 销毁状态,如下代码所示:

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 获取当前线程状态
        Thread.State state = Thread.currentThread().getState();
        // 打印线程状态
        System.out.println("获取线程状态:" + state);
    }
});
// 启动线程
thread.start();
// 等待 100ms,待线程执行完
Thread.sleep(100);
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("线程状态:" + state);
复制代码

以上程序的执行结果如下图所示:

总结
Java 中线程的生命周期有 6 种:NEW(初始化状态)、RUNNABLE(可运行/运行状态)、BLOCKED(阻塞状态)、WAITING(无时限等待状态)、TIMED_WAITING(有时限等待状态)、TERMINATED(终止状态)。线程生命周期的转换流程如下图所示:

最后
如果你觉得此文对你有一丁点帮助,点个赞。或者可以加入我的开发交流群:1025263163相互学习,我们会有专业的技术答疑解惑

如果你觉得这篇文章对你有点用的话,麻烦请给我们的开源项目点点star:http://github.crmeb.net/u/defu不胜感激 !

PHP学习手册:https://doc.crmeb.com
技术交流论坛:https://q.crmeb.com

03-05 20:54