首页 > hot资讯 > 实例分析线程的生命周期

实例分析线程的生命周期

更新时间:2020-11-25 17:49 浏览77次 来源:动力节点

线程是一个动态执行的过程,线程也有“生老病死”的生命周期,线程的生命周期其实就是一个线程从创建到消亡的过程。对于有生命周期的事物,要学好它,思路非常简单,只要能搞懂生命周期中各个节点的状态转换机制就可以了。

在Java语言中,线程的生命周期中要想确定一个线程的当前状态,可调用getState方法。下面就借助getState方法来用实例分析线程的生命周期:

 

1.初始化

NEW表示线程创建了,但是还没有开始执行。

public class NewThread implements Runnable{

    public static void main(String[] args) {

        Runnable runnable = new NewThread();

        Thread t = new Thread(runnable);

        log.info(t.getState().toString());

    }

 

    @Override

    public void run() {

 

    }

}

上面的代码将会输出:

NEW

 

2.可运行

Runnable表示线程正在运转状态。包括正在运行和准备运行两种。

为什么这两种都叫做Runnable呢?我们知道在多任务环境中,CPU的个数是有限的,所以任务都是轮循占有CPU来处理的,JVM中的线程调度器会为每个线程分配特定的执行时间,当执行时间结束后,线程调度器将会释放CPU,以供其他的Runnable线程执行。

我们看一个Runnable的例子:

public class RunnableThread implements Runnable {

    @Override

    public void run() {

 

    }

 

    public static void main(String[] args) {

        Runnable runnable = new RunnableThread();

        Thread t = new Thread(runnable);

        t.start();

        log.info(t.getState().toString());

    }

}

上面的代码将会输出:

RUNNABLE

 

3.已封锁

BLOCKED表示线程正在等待资源锁,而当前该资源正在被其他线程占有。

我们举个例子:

public class BlockThread implements Runnable {

    @Override

    public void run() {

        loopResource();

    }

 

    public static synchronized void loopResource() {

        while(true) {

            //无限循环

        }

    }

 

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new BlockThread());

        Thread t2 = new Thread(new BlockThread());

 

        t1.start();

        t2.start();

 

        Thread.sleep(1000);

        log.info(t1.getState().toString());

        log.info(t2.getState().toString());

        System.exit(0);

    }

}

上面的示例中,由于t1是无限循环,将会一直占有资源锁,导致t2无法获取资源锁,从而处于BLOCKED状态。

我们会得到如下结果:

12:40:11.710 [main] INFO com.flydean.BlockThread - RUNNABLE

12:40:11.713 [main] INFO com.flydean.BlockThread - BLOCKED

 

4.等候

WAITING状态表示线程正在等待其他的线程执行特定的操作。有以下方法可以导致线程处于WAITTING状态:

 

object.wait()

thread.join()

LockSupport.park()

 

其中1,2方法不需要预期时间参数。

我们看下使用的例子:

public class WaitThread implements  Runnable{

 

    public static Thread t1;

    @Override

    public void run() {

        Thread t2 = new Thread(()->{

            try {

                Thread.sleep(10000);

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

                log.error("Thread interrupted", e);

            }

            log.info("t1"+t1.getState().toString());

        });

        t2.start();

 

        try {

            t2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

            log.error("Thread interrupted", e);

        }

        log.info("t2"+t2.getState().toString());

    }

 

    public static void main(String[] args) {

        t1 = new Thread(new WaitThread());

        t1.start();

 

    }

}

在这个例子中,我们调用的t2.join(),这导致调用它的t1线程处于WAITTING状态。

我们看下输出结果:

12:44:12.958 [Thread-1] INFO com.flydean.WaitThread - t1 WAITING

12:44:12.964 [Thread-0] INFO com.flydean.WaitThread - t2 TERMINATED

TIMED_WAITING

TIMED_WAITING状态表示在一个有限的时间等待其他线程执行特定的某些操作。

java中有5中方式来达到这种状态:

thread.sleep(长毫秒)

wait(int timeout)或者wait(int timeout,int nanos)

thread.join(长毫秒)

LockSupport.parkNanos

LockSupport.parkUntil

 

我们举个例子:

public class TimedWaitThread implements  Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(5000);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

            log.error("Thread interrupted", e);

        }

    }

 

    public static void main(String[] args) throws InterruptedException {

        TimedWaitThread obj1 = new TimedWaitThread();

        Thread t1 = new Thread(obj1);

        t1.start();

 

        // The following sleep will give enough time for ThreadScheduler

        // to start processing of thread t1

        Thread.sleep(1000);

        log.info(t1.getState().toString());

    }

}

上面的例子中我们调用了Thread.sleep(5000)来让线程处于TIMED_WAITING状态。

看下输出:

12:58:02.706 [main] INFO com.flydean.TimedWaitThread - TIMED_WAITING

那么问题来了,TIMED_WAITING和WAITTING有什么区别呢?

TIMED_WAITING如果在给定的时间没有等到其他线程的特定操作,则被唤醒,从而进入争夺资源锁的状态,如果能够获取到锁,则变成Runnable状态,如果获取不到锁,则变为变成BLOCKED状态。

 

5.已终止

TERMINATED表示线程已经执行完毕。

public class TerminatedThread implements Runnable{

    @Override

    public void run() {

 

    }

 

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new TerminatedThread());

        t1.start();

        // The following sleep method will give enough time for

        // thread t1 to complete

        Thread.sleep(1000);

        log.info(t1.getState().toString());

    }

}

输出结果:

13:02:38.868 [main] INFO com.flydean.TerminatedThread - TERMINATED

 

理解Java线程的生命周期及各种状态对于诊断多线程 Bug 非常有帮助,多线程程序很难调试,出了 Bug 基本上都是靠日志,靠线程 dump 来跟踪问题,分析线程 dump 的一个基本功就是分析线程状态,大部分的死锁、饥饿、活锁问题都需要跟踪分析线程的状态。关于这方面的详细讲解可以参考本站的Java多线程教程,里面对此举出了大量的实例供我们学习论证。


热门课程推荐

全部班型支持免费试学

动力节点在线报名表(此信息已加密,请放心填写)

返回顶部