欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java线程的生命周期(有代码演示)

程序员文章站 2022-07-10 21:23:24
文章目录概览NEWRUNNABLEBLOCKEDWAITINGWAITINGTERMINATED概览Java语言中,多线程是由线程的核心概念驱动的,而线程的生命周期会经历以下的不同状态。Java java.lang.Thread类包含了一个静态类State,它定义了线程的状态,在任意一个时间点上,线程只可能是其中的一个状态,我们接下来逐一讨论每个状态。NEW新创建且还未被执行的线程在我们调用start()方法之前当前线程将一直保持该状态:Runnable runnable = new N...

概览

Java语言中,多线程是由线程的核心概念驱动的,而线程的生命周期会经历以下的不同状态。
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()后且未结束前活跃。

本文地址:https://blog.csdn.net/HalfImmortal/article/details/107409063