并发系列之线程生命周期

加州大学洛杉机分校（美国）校训：“让此地闪耀。”

今天，忙里偷闲，就顺便多整理一篇文章，聊聊线程的生命周期吧。代码敲多了的时候，看到对象化的东西，就想了解下它的生命周期，即创建/初始化/运行/销毁这四件套，那今天就聊聊线程的四件套。

一概述生命周期

线程的生命周期可根据线程的状态划分为如下几个阶段：

1 新建

创建线程对象时的状态，如new

2 就绪

调用start()方法后线程进入的状态，此时线程并不一定进入运行状态，因为这是由操作系统的调度程序控制的

3 运行

线程获得CPU的执行权，正在执行线程体包含的代码块

4 阻塞

线程在等待一个锁资源或者被挂起等，指阻塞状态，这是被动状态

5 等待

线程主动发起的执行暂停延缓等，分为有限期等待和无限期等待

6 结束

线程正常执行完或其他因素导致的终止

二线程的创建

线程创建方式如下：

1 Thread类简单，直接上代码

/**
 * @author 阿伦故事
 * @Description：描述线程创建的方式
 * */
@Slf4j
public class ThreadCreate {

    public static void main(String[] args) {
        log.info("--begin create thread--");
        ByThread byThread = new ByThread();
        log.info("--激活线程 进入就绪状态--");
        byThread.start();
        log.info("--线程执行结束--");
    }
    /**
     * way1 ：
     *      继承Thread
     * */
    public static class ByThread extends Thread{

        @Override
        public void run(){
            log.info("--这是线程体需要执行的代码块--");
        }
    }
}

2 Runable接口

/**
 * @author 阿伦故事
 * @Description：描述线程创建的方式
 * */
@Slf4j
public class ThreadCreate {

    public static void main(String[] args) {
        log.info("--begin create thread--");
        Thread byRunable = new Thread(new ByRunable());
        log.info("--激活线程 进入就绪状态--");
        byRunable.start();
        log.info("--线程执行结束--");
    }
    /**
     * way2 ：
     *      实现Runnable
     *      注意的是ByRunable对象并不是一个真正的线程对象，
     *      需要由Thread包装
     * */
    public static class ByRunable implements Runnable{

        @Override
        public void run(){
            log.info("--这是Runnable方式线程体需要执行的代码块--");
        }
    }
}

3 Callable接口关注线程执行结果的时候使用

/**
 * @author 阿伦故事
 * @Description：描述线程创建的方式
 * */
@Slf4j
public class ThreadCreate {

    public static void main(String[] args) {
        log.info("--begin create thread--");
        FutureTask futureTask = new ByCallable().create();
        Thread byCallable = new Thread(futureTask);
        log.info("--激活线程 进入就绪状态--");
        byCallable.start();
        try {
            log.info("--线程执行结束--返回结果："+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    /**
     * way3 ：
     *      实现Callable，接收返回值
     * 步骤：
     *      1 创建Callable接口的实现，并重写call方法
     *      2 使用FutureTask来包装返回的结果
     *      3 把FutureTask放到new Thread()里执行
     *      4 通过FutureTask的get方法获取返回结果，是阻塞的
     * 简易：
     *      这里使用Lambda表达式方式实现，也是工作中推荐的方式
     * */
    public static class ByCallable {

        public FutureTask create(){
            FutureTask futureTask = new FutureTask(() ->{
                int count = 0;
                int i = 0;
                while(count < 100){
                    count += I++;
                }
                return count;
            });
            return  futureTask;
        }
    }
}

三线程的等待

线程的等待可以分为两类考虑，一种是被动的阻塞，另一种是主动的暂停执行；而主动的等待又分为有限期的等待和无限期的等待，如下：

1 阻塞

当线程试图进入一个加锁的代码块，此线程如果未拿到锁，则只能在临界区外等待，这是被动引发的。所以我们可以把线程的阻塞理解为特定的锁等待。

2 无限期等待

处于这种状态的线程不会被CPU分配时间片，只能等待被其他线程唤醒，如：
a/Object.wait()方法，不带timeout参数
b/Thread.join()方法，不带timeout参数
c/LockSupport.park(Object var0)方法

3 有限期等待

处于这种状态的线程不会被CPU分配时间片，但它们无需等待其他线程唤醒，只需等待指定的时间后由系统自动唤醒，如：
a/Object.wait(long timeout)方法，带timeout参数
b/Thread.join(long var1)方法，带timeout参数
c/Thread.sleep(long var0)方法
d/LockSupport.parkNanos(Object var0, long var1)方法
e/LockSupport.parkUntil(Object var0, long var1)方法

四线程的结束

1 线程执行完成正常结束，如run()/call()正常执行完
2/线程在执行过程中抛出一个未被捕获的Exception或Error
3/调用线程自身的stop()方法来结束，此方法已被废弃，在开发过程中严禁使用，因为在关闭过程中可能会发生不可预知的后果。
附送线程状态转换图：

线程状态转换.jpg

特此声明：
分享文章有完整的知识架构图，将从以下几个方面系统展开：
1 基础（Linux/Spring boot/并发）
2 性能调优（jvm/tomcat/mysql）
3 高并发分布式
4 微服务体系
如果您觉得文章不错，请关注阿伦故事，您的支持是我坚持的莫大动力，在此受小弟一拜！

每篇福利：

评论区打出车型.jpg

并发系列之线程生命周期