乐趣区

关于java:面试突击-23说一下线程生命周期以及转换过程

jiezi

线程的生命周期指的是线程从创立到销毁的整个过程，通常状况下线程的生命周期有以下 5 种：

  • 初始状态
  • 可运行状态
  • 运行状态
  • 休眠状态
  • 终止状态

它们的状态转换如下图所示：

Java 线程生命周期

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

  1. NEW（初始化状态）
  2. RUNNABLE（可运行 / 运行状态）
  3. BLOCKED（阻塞状态）
  4. WAITING（无时限期待状态）
  5. TIMED_WAITING（有时限期待状态）
  6. 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（终止状态）。线程生命周期的转换流程如下图所示：

参考资料

《Java 并发编程实战》
​

是非审之于己，毁誉听之于人，得失安之于数。

公众号：Java 面试真题解析

面试合集：https://gitee.com/mydb/interview

退出移动版