1、初识线程

一、并发的发展历史

1、真空管和穿孔打卡
运行方式：程序–>穿孔卡片–>输入（输入室）–>执行–>打印结果
2、晶体管和批处理系统
运行方式：在输入室收集全部–>执行–>打印结果
优势：计算机始终处于运算状态，合理的利用了计算机资源
3、集成电路和多道程序设计
提示：①、内存分为几个部分，每一个部分放不同的程序。（当一个程序需要等待I/O 操作完成时。那么 CPU 可以切换执行内存中的另外一个程序。）
②、进程，进程的本质是一个正在执行的程序，程序运行时系统会创建一个进程，并且给每个进程分配独立的内存地址空间保证每个进程地址不会相互干扰。
③、线程：1. 在多核 CPU 中，利用多线程可以实现真正意义上的并行
执行
2. 在一个应用进程中，会存在多个同时执行的任务，如果
其中一个任务被阻塞，将会引起不依赖该任务的任务也
被阻塞。通过对不同任务创建不同的线程去处理，可以
提升程序处理的实时性
3. 线程可以认为是轻量级的进程，所以线程的创建、销毁
比进程更快

二、线程的应用

继承Thread表，实现Runnable接口、使用 ExecutorService、Callable、Future实现可返回结果的多线程
1、继承Thread
实现方式：自己的类继承Thread，并重写run()方法
启动：调用start（）方法，（它会启动一个线程，并调用run（）方法）

public class MyThread extends Thread{

    @Override
    public void run() {
        System.out.println("MyThread.run()");
    }

    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread1.start();
        myThread2.start();
    }
}

2、实现 Runnable 接口创建线程
如果自己的类已经 extends 另一个类，就无法直接 extends Thread，此时，可以实现一个 Runnable 接口

public class MyThread1 implements Runnable{
    public void run() {
        System.out.println("MyThread.run()");
    }
}

3、实现 Callable 接口通过FutureTask 包装器来创建 Thread 线程

public class CallableDemo implements Callable<String> {

    public String call() throws Exception {
        int a = 1;
        int b = 2;
        System.out.println(a + b);
        return "执行结果:" + (a + b);
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        CallableDemo callableDemo = new CallableDemo();
        Future<String> future = executorService.submit(callableDemo);
        System.out.println(future.get());
        executorService.shutdown();
    }
}

三、应用场景

平时很少用到，主要涉及到批量的或许有用，源码中经常用到
例：zookeeper源码中异步责任链

public class PrintProcessor extends Thread implements RequestProcessor {

    //    消息队列集合
    LinkedBlockingQueue<Request> requests = new LinkedBlockingQueue<Request>();
//         下一个请求进程
    private final RequestProcessor nextProcessor;

    public PrintProcessor(RequestProcessor nextProcessor) {
        this.nextProcessor = nextProcessor;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Request request = requests.take();

                System.out.println("print  data:" + request.getName());

                nextProcessor.processRequest(request);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void processRequest(Request request) {
        this.requests.add(request);
    }
}

代码地址：https://github.com/MrWanglihua/thread

四、Java 并发编程的基础

1、线程的生命周期
线程一共有 6 种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIME_WAITING、TERMINATED）
①、NEW：初始状态，线程被构建，但是还没有调用 start 方法
②、RUNNABLED：运行状态，JAVA 线程把操作系统中的就绪和运行两种状态统一称为“运行中”
③、BLOCKED：阻塞状态，表示线程进入等待状态,也就是线程因为某种原因放弃了 CPU 使用权，阻塞也分为几种情况
➢ 等待阻塞：运行的线程执行 wait 方法，jvm 会把当前线程放入到等待队列
➢ 同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被其他线程锁占用了，那么 jvm 会把当前的线程放入到锁池中
➢ 其他阻塞：运行的线程执行 Thread.sleep 或者 t.join 方法，或者发出了 I/O 请求时，JVM 会把当前线程设置为阻塞状态，当 sleep 结束、join 线程终止、io 处理完毕则线程恢复
④、TIME_WAITING：超时等待状态，超时以后自动返回
⑤、TERMINATED：终止状态，表示当前线程执行完毕
1、初识线程
2、代码展示

package com.thread.v2;

import jdk.nashorn.internal.ir.Block;

import java.util.concurrent.TimeUnit;

public class ThreadStatus {

    public static void main(String[] args) {

//        TIME_WAITING
        new Thread(()->{
            while(true){
                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"time_waiting").start();
//        WAITING,线程通过在ThreadStatus类锁上通过wait进行等待
        new Thread(()->{
            while(true){
                synchronized(ThreadStatus.class){
                    try {
                        ThreadStatus.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"Waiting").start();
//        线程在ThreadStatus加锁后，不会释放锁
        new Thread(new BlockDemo(),"BlockDemo1").start();
        new Thread(new BlockDemo(),"BlockDemo2").start();
    }


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


}

**注：**启动线程前需要给每个线程添加名字，以为在使用jstack分析程序时或者进行问题排查时，会给你提供一些提示
3、线程启动：调用start方法
源代码：

 private native void start0();

我们看到调用 start 方法实际上是调用一个 native 方法start0()来启动一个线程，首先 start0()这个方法是在Thread 的静态块中来注册的，代码如下

  /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }

registerNatives 的 本 地 方 法 的 定 义 在 文 件Thread.c,Thread.c定义了各个操作系统平台要用的关于线程的公共数据和操作，以下是 Thread.c 的全部内容
http://hg.openjdk.java.net/jdk8/jdk8/jdk/file/00cd9dc3c2b5/src/share/native/java/lang/Thread.c
调用JVM相关的jvm.cpp文件调用一个JVM_ENTRY 是用来定义 JVM_StartThread 函数的
1、初识线程
在thread.ccp文件继续看1、初识线程
实际是用平台提供的方法创建线程启动线程：会调用thread.ccp文件中的Thread::start(Thread)
1、初识线程
最终调用Runnable方法，既调用run()方法
4、线程的终止：
并不是简单的stop（）方法（不建议用），stop()方法在结束一个线程时并不会保证一个线程的资源正常释放，因此程序可能出现一些不确定性，线程提供interrupt方法
①、interrupt方法
当其他线程通过调用当前线程的 interrupt 方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己。
线程通过检查自身是否被中断来进行相应，可以通过isInterrupted()来判断是否被中断。
通过下面这个例子，来实现了线程终止的逻辑

public class InterruptDemo {
    private static int i;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) { //默认情况下isInterrupted 返回 false、通过 thread.interrupt 变成了 true
                i++;
            }
            System.out.println("Num:" + i);
        }, "interruptDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt(); //加和不加的效果
    }
}

②、Thread.interrupted
上面的案例中，通过 interrupt，设置了一个标识告诉线程可 以 终 止 了 ， 线 程 中 还 提 供 了 静 态 方 法Thread.interrupted()对设置中断标识的线程复位。

public class InterruptDemo1 {
    private static int i;
    public static void
    main(String[] args) throws
            InterruptedException {
        Thread thread=new Thread(()->{
            while(true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println("before:"+Thread.currentThread().isInterrupted())
                    ;
                    Thread.interrupted(); // 对线程进行复位，由 true 变成 false
                    System.out.println("after:"+Thread
                            .currentThread().isInterrupted());
                }
            }
        },"interruptDemo");
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
    }
}

③、为什么要复位
Thread.interrupted()是属于当前线程的，是当前线程对外界中断信号的一个响应，表示自己已经得到了中断信号，但不会立刻中断自己，具体什么时候中断由自己决定，让外界知道在自身中断前，他的中断状态仍然是 false，这就是复位的原因。
④、线程的终止原理
这个方法里面，调用了 interrupt0()，这个方法在前面分析start 方法的时候见过，是一个 native 方法，这里就不再重复贴代码了，同样，我们找到 jvm.cpp 文件，找到JVM_Interrupt 的定义
1、初识线程
这个方法比较简单，直接调用了 Thread::interrupt(thr)这个方法，这个方法的定义在 Thread.cpp 文件中，代码如下
1、初识线程
Thread::interrupt 方法调用了 os::interrupt 方法，这个是调用平台的 interrupt 方法，这个方法的实现是在 os_*.cpp文件中，其中星号代表的是不同平台，因为 jvm 是跨平台的，所以对于不同的操作平台，线程的调度方式都是不一样的。我们以 os_linux.cpp 文件为例
1、初识线程
set_interrupted(true)实际上就是调用 osThread.hpp 中的set_interrupted()方法，在 osThread 中定义了一个成员属性 volatile jint _interrupted;通过上面的代码分析可以知道，thread.interrupt()方法实际就是设置一个 interrupted 状态标识为 true、并且通过
ParkEvent 的 unpark 方法来唤醒线程。

  1. 对于 synchronized 阻塞的线程，被唤醒以后会继续尝试
    获取锁，如果失败仍然可能被 park
  2. 在调用 ParkEvent 的 park 方法之前，会先判断线程的中
    断状态，如果为 true，会清除当前线程的中断标识

Object.wait 、 Thread.sleep 、 Thread.join 会 抛 出InterruptedException

这里给大家普及一个知识点，为什么 Object.wait、Thread.sleep 和 Thread.join 都 会 抛 出InterruptedException? 你会发现这几个方法有一个共同点，都是属于阻塞的方法
而阻塞方法的释放会取决于一些外部的事件，但是阻塞方法可能因为等不到外部的触发事件而导致无法终止，所以它允许一个线程请求自己来停止它正在做的事情。当一个方法抛出 InterruptedException 时，它是在告诉调用者如果执行该方法的线程被中断，它会尝试停止正在做的事情并且通过抛出 InterruptedException 表示提前返回。
所以，这个异常的意思是表示一个阻塞被其他线程中断了。然后，由于线程调用了 interrupt()中断方法，那么Object.wait、Thread.sleep 等被阻塞的线程被唤醒以后会通过 is_interrupted 方法判断中断标识的状态变化，如果发现中断标识为 true，则先清除中断标识，然后抛出InterruptedException需要注意的是，InterruptedException 异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，至于接下来怎么处理取决于线程本身，比如

  1. 直接捕获异常不做任何处理
  2. 将异常往外抛出
  3. 停止当前线程，并打印异常信息
    为 了 让 大 家 能 够 更 好 的 理 解 上 面 这 段 话 ， 我 们 以
    Thread.sleep 为例直接从 jdk 的源码中找到中断标识的清
    除以及异常抛出的方法代码
    找 到 is_interrupted() 方 法 ， linux 平 台 中 的 实 现 在
    os_linux.cpp 文件中，代码如下
    1、初识线程
    找到 Thread.sleep 这个操作在 jdk 中的源码体现，怎么找?
    相信如果前面大家有认真看的话，应该能很快找到，代码
    在 jvm.cpp 文件中
    1、初识线程
    注 意 上 面 加 了 中 文 注 释 的 地 方 的 代 码 ， 先 判 断is_interrupted 的 状 态 ， 然 后 抛 出 一 个InterruptedException 异常。到此为止，我们就已经分析清楚了中断的整个流程。

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode