Java线程的生命周期

目录
  • 概览
  • NEW
  • RUNNABLE
  • BLOCKED
  • WAITING
  • TIMED_WAITING
  • TERMINATED

概览

Java语言中,多线程是由线程的核心概念驱动的,而线程的生命周期会经历以下的不同状态。
Java线程的生命周期_第1张图片

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

TIMED_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()后且未结束前活跃。

你可能感兴趣的:(Java线程的生命周期)