java并发编程 ||Thread生命周期详解

最新推荐文章于 2024-05-30 10:09:19 发布

小小攻城狮Jack

最新推荐文章于 2024-05-30 10:09:19 发布

阅读量865

点赞数

本文链接：https://blog.csdn.net/qq_40111437/article/details/104902220

版权

并发的发展历史

真空管/穿孔打卡

场景：首先把程序按规则写到纸上，穿孔打成卡片，然后把卡片放到输入室并且放到输入设备，专人把卡片的程序写到计算机上，等计算机完成计算以后，会把结果打印输出到打印机上

特点（问题）：计算机大部分时间处于空闲状态，卡片输入之前浪费一大波时间。

晶体管/批处理操作系统

场景：和上面比计算机不需要等待了，可以不断的从磁带机里面拿取磁带，这样就把上面浪费的时间省了。

特点（问题）：系统批量处理一个程序的时候，如果一个指令卡了，意味着后续所有指令都会阻塞，因为它是串行化的，所以这样又造成了资源的浪费，所以怎么最大化利用cpu资源。

集成电路/多道程序设计

场景：进程A（阻塞）/进程B（运行）

特点：出现了线程的概念。

什么是线程？

线程：线程是进程的一个实体，是cpu调度和分派的基本单位，比进程更小而独立运行的单位，比如打开一个word就是一个进程，但在这个进程中可以有多个线程，它可以和同属一个进程的其它线程共享进程的所有操作资源。

多线程：多线程指在单个进程中可以同时运行多个不同线程来执行不同的任务。

为什么需要线程？

1.单核-》多核-》真正意义上达到并行的计算，也就是最大化的利用cpu的资源，当某一线程的处理不需要占用cpu而只和io等打交道的时候，让需要占用cpu的其它线程有机会占用cpu资源。

2.实时性的需求（如果没有多线程，当你处理程序并且写到磁盘的时候，中间断电就会把这一整条操作的数据全部丢失）。

java中如何实现线程，4中实现方式

1.Runnable接口

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 10:41 2020-3-17
 */
public class AppRunnable implements Runnable{
    public static void main(String[] args) {
        AppRunnable appRunnable = new AppRunnable();
        Thread thread = new Thread(appRunnable);
        thread.start();
    }

    @Override
    public void run() {
        System.out.println("线程做一些事情");
    }
}

2.Thread类（本质上是对Runnable接口的实现）

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 17:07 2020-3-16
 */
public class AppThread extends Thread{
    public static void main(String[] args) {
        AppThread appThread = new AppThread();
        appThread.start();
        //jdk1.8以后更喜欢这样写
        new Thread(()->{
            System.out.println("线程2做一些事情");
        }).start();
    }

    @Override
    public void run() {
        System.out.println("线程做一些事情");
    }
    
}

对jdk8以后的新语法有兴趣的同学可以参考我的另外一篇博客java8新特性之Lambda表达式篇----为什么代码更少。

那我们来看看为什么能够这样做呢，其实就是Thread类的两种构造方法而已，一种是无参，自己重写Thread里面的run方法，一种是有参，传一个Runnable接口的子类就可以了，两者都实现了构造一个线程的目的。

3.Callable/Future 带返回值得线程（）

4.ThreadPool

线程的基本体系

1.线程的生命周期（6个）

关于线程的生命周期，我们可以通过Thread类里面的枚举类state来进行理解。

这个枚举类就定义了Thread的6中生命状态，并且定义了每种状态对应的情况。

当线程进行new状态的时候，线程还没有运行，只是等待cpu分配时间片，当cpu分配了时间片以后，线程就进入了runnable状态，对应代码中也就是运行你重写run方法中的代码块，而当线程在runnable状态的时候，又可能出现三种状况（上图中已经展示出java是通过什么方法使线程进入对应状态），分别为waiting（等待），time_waiting(超时等待，与前一个的区别在于可以设置等待时间)，blocked（阻塞于锁），这3种其实都相当于阻塞住了线程，使线程不能够继续运行下去，当这3种状态被复位时，线程便会继续执行run方法中的代码直到运行完毕后，进入terminated状态，也就代表这个线程结束了。

2.线程的3种阻塞状态

接下来我们看看用代码怎么模拟这三种状态：

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 9:24 2020-3-17
 */
public class ThreadCycleDemo {
    public static void main(String[] args) {
        //线程进入time_waiting状态
        new Thread(()->{
            while(true){
                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"TIME_WAITING_THREAD").start();

        //线程进入waiting状态
        new Thread(()->{
            while(true){
                //wait方法必须加锁
                synchronized (ThreadCycleDemo.class){
                    try {
                       ThreadCycleDemo.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"WAITING_THREAD").start();

        //线程进入blocked状态
        new Thread(new BlockThreadDemo(),"Thread-block-1").start();
        new Thread(new BlockThreadDemo(),"Thread-block-2").start();


    }

    public static class BlockThreadDemo extends Thread{
        @Override
        public void run() {
           synchronized (BlockThreadDemo.class){
               while(true){
                   try {
                       TimeUnit.SECONDS.sleep(100);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
        }
    }
}

运行以后我们会发现什么都没有，那么此时我们怎么查看我们线程的情况呢。

首先我们找到项目中编译的class的包

右键选项打开控制台，并且输入jps

我们会看到这么几个pid，选择我们需要查看的class的pid，输入 jstack 5220

我们就可以看到我们当前class中哪些线程是处于阻塞状态的，这样就能通过线程的name来查看相应线程的问题了。

3.线程的启动为什么是start（线程是怎么从new状态到runnable状态的）

首先如果是run的话不就等于类调用下当前方法了吗？

我们进入start方法种去看看，发现它其实是调用了一个原生的start0（）方法。

通过去查看jvm源码（这里是hotpot），我们看到start0（）对应的方法是JVM_StartThread（）

调用操作系统创建了一个线程

调用操作系统改变线程状态，并且开始这个这个线程，所以这就是为什么调用了start，线程状态就变成了runnable

我们发现它里面关键的两步，它会先new一个javaThread，然后把这个javaThread传进这个线程的start方法中，其实我们调用这个start方法，底层创建线程是操作系统帮我们完成的。

4.线程的终止（线程的terminated状态）

一定不要是stop（）方法，正常我们都会想到调用stop方法，但是我们会发现停止，挂起，恢复等方法都是过时的方法，因为这些都是不安全的操作，就有点像linux上的kill 线程方法，你没有办法知道这些线程的操作状态，不知道它是否工作完毕了，所以我们一定是不建议用这些方法的，而是建议以一个flag来判断线程是否需要被复位，那就是interrupt方法。

我们来看看interrupt（）方法是怎么停止线程的

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 14:59 2020-3-17
 */
public class ThreadInterruptDemo {
    private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {//默认是false
                i++;
            }
            System.out.println("输出i：" + i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        //把isInterrupted设置成true
        thread.interrupt();

    }
}

它是根据isInterrupt返回的boolean指来判断的，它其实相当于就是Thread里面有个true，false的成员变量的标志，但它实际上不是用boolean来体现的，而是用0和1，我们来看看这个interrupt方法。

你会发现它又调用了原生的interrupt0方法，老办法，看hotpot。

我们发现它是线程传入这个操作系统（linux为例子）调用的interrupt方法，然后它掉了OSThread的setInterrupt方法为true。

最后我们发现true就是返回1，false是返回0，所以默认是0，复位是1。

线程为什么要复位？

我们会发现很多阻塞catch的异常，都是interrupt，我们来看看这个异常出现后，isInterrupt的返回值。


/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 14:59 2020-3-17
 */
public class ThreadInterruptDemo {
    private static int i = 0;

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

        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {//默认是false
                try {
                    TimeUnit.SECONDS.sleep(5);//中断一个处于阻塞状态的线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("输出i：" + i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
        System.out.println(thread.isInterrupted());
    }

我们发现如果异常了，这个值还是会复位成false，这有什么用呢？

出现这个异常它就是告诉我们其它线程一个信号，我这里出现了问题，但是我这个线程还是在运行的，如果它发现中断标志为true的话，它会对其复位成false，只是给其它线程一个通知。

这样当线程调用这些wait、sleep、join方法的时候，使用notify，等待sleep时间等就可以拿到一个标志，来判断这个线程是否成功运行完毕，概述一下就是，当前线程表示我已经收到了一个中断的信号，但我可能不会立刻中断自己，并且让其它调用者知道我在中断之前，我的中断状态依然是false。

5、线程怎么按顺序执行

按照上面的概念，既然线程是等待时间片来执行的，那么cpu分配时间片的时间非常有可能是乱序的，如果现在需要我们保证线程执行的顺序，我们应该怎么做。

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 10:22 2020-4-9
 */
public class ThreadPool {
    static Thread thread1 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行");
    },"线程1");

    static Thread thread2 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行");
    },"线程2");

    static Thread thread3 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行");
    },"线程3");



    public static void main(String[] args) throws InterruptedException {
        //ExecutorService executorService = Executors.newCachedThreadPool();
        thread1.start();
        //thread1.join();
        thread2.start();
        //thread2.join();
        thread3.start();
    }
}

方法一：使用join方法，去保证多线程的顺序性。

把上面的注释打开，运行。

join的作用是让主线程等待子线程结束以后才能继续运行；基于这句话的概念我们打开源码看看，我们发现它其实是通过wait方法来确保线程执行的，其实就是wait方法拿到了锁，然后运行完毕释放锁，所以，join的方法其实是基于wait方法来完成的，但是这里有一个误区，并不是子线程来等待，而且让主线程等待。

 public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

方法二：通过初始化一个单线程池来实现，单线程池采用的是先进先出的原则，所以只有第一个线程完成以后才会执行下一个线程，而且你会发现你给线程命名也不起作用了，因为线程池中只有一个线程。

/**
 * @Author Dark traveler
 * @Note 我心净处，何处不是西天。
 * @Descrption
 * @E-Mail : 1029149772@qq.com
 * @Date : Created in 10:22 2020-4-9
 */
public class ThreadPool {
    static Thread thread1 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行第一个线程");
    },"线程1");

    static Thread thread2 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行第二个线程");
    },"线程2");

    static Thread thread3 = new Thread(()->{
        System.out.println(Thread.currentThread().getName()+":执行第三个线程");
    },"线程3");



    public static void main(String[] args) throws InterruptedException {
        //ExecutorService executorService = Executors.newCachedThreadPool();
        /*thread1.start();
        thread1.join();
        thread2.start();
        thread2.join();
        thread3.start();*/
        //使用初始化线程池方式，初始化一个单线程线程池  FIFO
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.submit(thread1);
        executorService.submit(thread2);
        executorService.submit(thread3);
        executorService.shutdown();

    }
}

小小攻城狮Jack

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java并发编程 ||Thread生命周期详解

并发的发展历史真空管/穿孔打卡场景：首先把程序按规则写到纸上，穿孔打成卡片，然后把卡片放到输入室并且放到输入设备，专人把卡片的程序写到计算机上，等计算机完成计算以后，会把结果打印输出到打印机上特点（问题）：计算机大部分时间处于空闲状态，卡片输入之前浪费一大波时间。晶体管/批处理操作系统场景：和上面比计算机不需要等待了，可以不断的从磁带机里面拿取磁带，这样就把上面浪费的时...
复制链接

扫一扫