Java线程的生命周期

Posted 2020-12-15 Mr靖哥哥

目录

• 概览
• NEW
• RUNNABLE
• BLOCKED
• WAITING
• WAITING
• TERMINATED

概览

Java语言中，多线程是由线程的核心概念驱动的，而线程的生命周期会经历以下的不同状态。

Java java.lang.Thread类包含了一个静态类State，它定义了线程的状态，在任意一个时间点上，线程只可能是其中的一个状态，我们接下来逐一讨论每个状态。

NEW

新创建且还未被执行的线程

在我们调用start()方法之前当前线程将一直保持该状态：

Runnable runnable = new NewState();
Thread t = new Thread(runnable);
log.info(t.getState());

由于我们还未调用start()方法，最后将打印

NEW

RUNNABLE

当前线程正在运行或处于就绪状态（等待CPU分配执行时间）

当我们调用start()方法之后，线程状态将由NEW状态切换到RUNABLE状态。

多线程环境下，线程调度器（属于JVM管辖）分配一定的时间给每个线程，当运行一定时间后将控制权交给其他可运行线程。

我们现在在上面的例子后面加上运行start()方法的代码再次获取一下当前的状态：

Runnable runnable = new NewState();
Thread t = new Thread(runnable);
t.start();
log.info(t.getState());

运行一下结果很有可能输出如下：

RUNNABLE

注意我们不能保证肯定会输出RUNNABLE状态，因为当我们调用t.getState()方法时，线程有可能执行完成了。

BLOCKED

等待获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生，之后当前线程进入同步区域

我们来看个例子：

public class BlockedState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new DemoThreadB());
        Thread t2 = new Thread(new DemoThreadB());
         
        t1.start();
        t2.start();
         
        Thread.sleep(1000);
        log.info(t2.getState());
        System.exit(0);
    }
}
 
class DemoThreadB implements Runnable {
    @Override
    public void run() {
        commonResource();
    }
     
    public static synchronized void commonResource() {
        while(true) {
            // 无限循环来模拟耗时操作
            // t1线程不会退出当前方法，t2线程无法进入
        }
    }
}

这段代码中，线程t1运行后进入到commonResource()同步方法中，这个一个排他锁，所有其他想进入该方法的线程都会被阻塞直到当前线程退出该方法。这时候线程t2也运行了，也需要访问commonResource()同步方法，但是由于线程t1在该方法中无限循环没有退出，t2将会一直保持BLOCKED状态，最后程序会打印：

BLOCKED

WAITING

当前线程不会被分配CPU执行时间，需被其他线程显示的唤醒

根据Java文档上解释，只有以下方法会让线程进入无限期的等待状态：

• 没有设置timeout参数的Object.wait()方法
• 没有设置timeout参数的Thread.join()方法
• LockSupport.park()方法

后面会另写一篇文章详细讨论wait()、notify() 、notifyAll()，下面面子先展示join()方法调用后线程进入WAITING状态：

public class WaitingState implements Runnable {
    public static Thread t1;
 
    public static void main(String[] args) {
        t1 = new Thread(new WaitingState());
        t1.start();
    }
 
    public void run() {
        Thread t2 = new Thread(new DemoThreadWS());
        t2.start();
 
        try {
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("Thread interrupted", e);
        }
    }
}
 
class DemoThreadWS implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("Thread interrupted", e);
        }
         
        log.info(WaitingState.t1.getState());
    }
}

这段代码中，我们运行主线程创建线程t1并运行t1，在t1中我们创建线程t2并运行t2，在t2运行时，我们在t1使用t2.join()等待t2运行结束，这会让t1进入WAITING状态直到t2结束，当t1在等待t2执行结束的时候，我们在t2方法中调用t1.getState()来查看t1的状态，程序输入如下：

WAITING

WAITING

当前线程也不会被分配CPU执行时间，不过无需被其他线程显示的唤醒，在一定时间之后会被系统自动唤醒

根据Java文档上解释，有以下5种方法能让线程进入限期等待状态：

• Thread.sleep()方法
• 设置了timeout参数的Object.wait()方法
• 设置了timeout参数的Thread.join()方法
• LockSupport.parkNanos()方法
• LockSupport.parkUntil()方法

我们来看个例子：

public class TimedWaitingState {
    public static void main(String[] args) throws InterruptedException {
        DemoThread obj1 = new DemoThread();
        Thread t1 = new Thread(obj1);
        t1.start();
         
        // 休眠一秒让线程调度器有足够的时间去运行线程t1
        Thread.sleep(1000);
        log.info(t1.getState());
    }
}
 
class DemoThread implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.error("Thread interrupted", e);
        }
    }
}

例子很简单，程序输出如下：

TIMED_WAITING

TERMINATED

当前线程已运行结束，已终止状态

后面会另写一篇文章详细讨论停止线程的不同方式，当前看下面的简单例子：

public class TerminatedState implements Runnable {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TerminatedState());
        t1.start();
        
        // 休眠1秒让线程t1有足够时间执行完毕
        Thread.sleep(1000);
        Log.info(t1.getState());
    }
     
    @Override
    public void run() {
        // 什么也不做
    }
}

程序输出如下：

TERMINATED

除了查看线程状态，我们还可以调用isAlive()方法来查看线程是否还活跃：

Assert.assertFalse(t1.isAlive());

当前状态下它会返回false，简单来说，线程只在调用start()后且未结束前活跃。