🚀1. 基本概念

🎉进程

程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载到 CPU，数据加载到内存。在指令运行过程中还需使用磁盘、网络等设备，进程就是用来加载指令、管理内存、管理 IO 的。

当一个程序运行，从磁盘加载这个程序的代码到内存，这时就开启了一个进程。

进程可以看作程序的一个实例，大部分程序可以同时运行多个进程实例（例如记事本，画图，浏览器等），也有的程序只能启动一个实例进程（如网易云音乐、360卫士等）。

🎉线程

一个进程之内可以分为多个线程。

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行。

在 Java 中，线程作为 CPU 调度执行的最小单位，进程作为资源拥有的最小单位，在 Windows 中进程是不活动的，只是作为线程的容器。

🎉进程和线程对比：

进程基本上相互独立的，而线程存在于进程内，是进程的一个子集。

进程拥有共享的资源，如内存空间等，供其内部的线程共享。

进程通信较为复杂

（1）同一台计算机的进程通信称为 IPC（Inter-process communication）

（2）不同计算机之间的进程通信，需要通过网络，并遵守共同的协议（如 HTTP）

线程通信相对简单，因为它们共享进程内的内存，例如多个线程可以访问同一个共享变量。

线程更加的轻量级，线程上下文切换成本一般要比进程上下文切换低。

🚀2. 并行与并发

✨单核 CPU 下，线程实际还是串行执行的，操作系统中有一个组件叫做任务调度器，将 CPU 的时间片（Windows 下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 CPU 在线程间（时间片很短）的切换非常快，让人感觉像是在同时运行的。实际就是，微观串行，宏观并行。

✨一般将线程轮流使用 CPU 的做法称为并发（Concurrent）。

✨多核 CPU 下，每个核（Core） 都可以调度运行线程，这时候线程是并行的。

🎉引用 Rob Pike 的一段描述

并行（Parallel）是同一时间动手做多件事情的能力

并发是同一时间应对多件事情的能力

🎉例如：

家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发。

家庭主妇雇了 2 个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）。

雇了 3 个保姆，一个专做饭、一个专打扫卫生、一个专喂奶，互不干扰，这时是并行。

🚀3. 应用

🚁3.1 应用之异步调用

🎉从调用角度来讲，如果

需要等待结果返回，才能继续运行就是同步。

不需要等待结果返回，就能继续运行就是异步。

（1）设计

多线程可以让方法执行变为异步（即不需要干巴巴等着），例如读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 CPU 什么都做不了，其他代码都需要暂停。

（2）结论

例如，在项目中视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程

tomcat 的异步 servlet 也是类似的操作目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程

UI 程序中，开线程进行其他操作，避免阻塞 UI 线程

🚁3.2 应用之提高效率

🎉（1）设计

充分利用多核 CPU 的优势，提高运行效率。想象下下面的场景，执行 3 个计算，最后将计算结果汇总。

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

如果串行执行，那么总共花费的时间时 10+11+9+1=31ms

如果是四核 CPU，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行时间，即 11ms，最后加上汇总时间只会花费 12 ms

值得注意的是，需要在多核 CPU 的前提下才能提高效率，单核 CPU 仍然是轮流执行。

🎉（2）结论

单核 CPU 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 CPU，不至于一个线程总占用 CPU，别的线程没法干活。

多核 CPU 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的

（1）有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率，但不是所有计算任务都能拆分

（2）也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率也没什么意义

🚀4. 创建线程并运行

🚁4.1 通过继承 Thread 创建线程

public class CreateThread {
  public static void main(String[] args) {
    Thread myThread = new MyThread();
        // 启动线程
    myThread.start();
  }
}
class MyThread extends Thread {
  @Override
  public void run() {
    System.out.println("My Thread running...");
  }
}

✨使用继承方式的好处就是在 run() 方法内获取当前线程直接使用 this 就可以了，无须使用Thread.currentThread（）方法；不好的地方是 Java 不支持多继承，如果继承了 Thread 类，那么就不能再继承其他类。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。

🚁4.2 使用 Runnable 配合 Thread (推荐)

public class Test {
  public static void main(String[] args) {
    //创建线程任务
    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println("Runnable running");
      }
    };
    //将 Runnable 对象传给 Thread
    Thread t = new Thread(runnable);
    //启动线程
    t.start();
  }
}

或者

public class CreateThread {
   private static class MyRunnable implements Runnable {
      @Override
      public void run() {
         System.out.println("my runnable running...");
      }
   }
   public static void main(String[] args) {
      MyRunnable myRunnable = new MyRunnable();
      Thread t = new Thread(myRunnable);
      t.start();
   }
}

✨通过实现 Runnable 接口，并且实现 run() 方法，在创建线程时作为参数传入该类的实例。

使用 lambda 精简代码

✨当一个接口带有 @FunctionalInterface 注解时，可以使用 lambda 来简化操作。

Runnable 接口源码如下

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

使用 lambda 简化后的代码如下

public class Test2 {
  public static void main(String[] args) {
    //创建线程任务
    Runnable r = () -> {
            //直接写方法体即可
      System.out.println("Runnable running");
      System.out.println("Hello Thread");
    };
    //将Runnable对象传给Thread
    Thread t = new Thread(r);
    //启动线程
    t.start();
  }
}

原理之 Thread 与 Runnable 的关系

分析 Thread 的源码，理清它与 Runnable 的关系。

public
class Thread implements Runnable {
   //...
}

🎉小结

方法 1 是把线程和任务合并在了一起，方法 2 是把线程和任务分开了

用 Runnable 更容易与线程池等高级 API 配合

用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

🚁4.3 FutureTask 配合 Thread

✨使用 FutureTask 可以用泛型指定线程的返回值类型（Runnable 的 run 方法没有返回值）

public class Test {
  public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需要传入一个Callable对象
    FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
      @Override
      public Integer call() throws Exception {
        System.out.println("线程执行!");
        Thread.sleep(1000);
        return 100;
      }
    });
    Thread r1 = new Thread(task, "t2");
    r1.start();
    //获取线程中方法执行后的返回结果
    System.out.println(task.get());
  }
}

或者

public class UseFutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new MyCall());
        Thread t = new Thread(futureTask);
        t.start();
        // 获得线程运行后的返回值
        System.out.println(futureTask.get());
    }
}
class MyCall implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "hello world";
    }
}

🚁4.4 小结

✨使用继承方式的好处就是方便传参，可以在子类里面添加成员变量，通过 set 方法设置参数或者通过构造函数进行传递，而如果使用 Runnable 方式，则只能使用主线程里面被声明为 final 的变量。不好的地方是 Java 不支持多继承，如果继承了 Thread 类，那么子类不能再继承其他类，而 Runable 则没有这个限制。前两种方式都没办法拿到任务的返回结果，但是 Futuretask 方式可以返回结果。

🚀5. 原理之线程运行

🎉栈与栈帧

JVM 中由堆、栈、方法区所组成，其中栈内存就是给线程分配的空间，每个线程启动后，虚拟机就会为其分配一块栈内存。

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

🎉线程上下文切换（Thread Context Switch）

因为以下一些原因导致 CPU 不再执行当前的线程，转而执行另一个线程的代码

线程的 CPU 时间片用完

垃圾回收

有更高优先级的线程需要运行

线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

✨发生上下文切换时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 JVM 指令的执行地址，是线程私有的。

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等

上下文切换频繁发生会影响性能

🚀6. 常用方法

🚁6.1 start 与 run

🏳️‍🌈调用 run

public static void main(String[] args) {
     Thread t1 = new Thread("t1") {
         @Override
         public void run() {
             log.debug(Thread.currentThread().getName());
             FileReader.read(Constants.MP4_FULL_PATH);
         }
     };
     t1.run();
     log.debug("do other things");
 }

输出

[main] c.TestStart - main
[main] c.FileReader - read [1.mp4] start ...
[main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
[main] c.TestStart - do other things ...

程序在 t1 线程运行，FileReader.read() 方法调用是异步的。

🎉小结：

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程
• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

🚁6.2 sleep 与 yield

🎉sleep（使线程阻塞）

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）

其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException

睡眠结束后的线程未必会立刻得到执行

建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性，如

//休眠一秒
TimeUnit.SECONDS.sleep(1);
//休眠一分钟
TimeUnit.MINUTES.sleep(1);

🎉yield

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程

具体的实现依赖于操作系统的任务调度器

🎉线程优先级

线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

如果 CPU 比较忙，那么优先级高的线程会获得更多的时间片，但是 CPU 空闲时，优先级几乎没有作用

设置优先级的方法

t.setPriority(Thread.MAX_PRIORITY); //设置为优先级最高

🚁6.3 join 方法

✨为什么需要 join？执行下面的代码，打印的 r 是什么？

static int r = 0;
public static void main(String[] args) {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

🎉分析

因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r = 10

而主线程一开始就要打印 r 的结果，所以只能打印出 r = 0

🎉解决方法

用 join 方法，加在 t1.start() 之后即可

🎉从调用的角度来讲，如果

需要等待结果返回才能继续运行就是同步

不需要等待结果返回，就能继续运行就是异步

✨等待多个结果，下面代码大概需要花费多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) {
    test2();
}
private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r = 10;
    });
    Thread t2 = new Thread(() -> {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

🎉分析如下：

• 第一个 join：等待 t1 时，t2 并没有停止，而在运行
• 第二个 join：1 秒后执行到此，t2 也运行了 1 秒，因此只需要再等待 1 秒

✨如果颠倒两个 join，最后的输出结果都是一样的。

✨其实，join 方法就是用于等待某个线程结束，哪个线程内调用 join 方法，就等待哪个线程结束，然后再去执行其他线程。

如在主线程中调用 thread.join()，则是主线程等待 t1 线程结束。

Thread thread = new Thread();
//等待thread线程执行结束
thread.join();
//最多等待1000ms,如果1000ms内线程执行完毕，则会直接执行下面的语句，不会等够1000ms
thread.join(1000);

🚁6.4 interrupt 方法

🎉interrupt 方法用于打断阻塞 (sleep wait join…) 的线程，处于阻塞状态的线程，CPU 不会给其分配时间片。

如果一个线程在运行中被打断，打断标记会被置为 true

如果是打断因 sleep wait join 方法而被阻塞的线程，会将打断标记置为 false

//用于查看打断标记，返回值被 boolean 类型
t1.isInterrupted();

✨正常运行的线程在被打断后，不会停止，会继续执行。如果要让线程在被打断后停下来，需要使用打断标记来判断。

while(true) {
    if(Thread.currentThread().isInterrupted()) {
        break;
    }
}

interrupt 方法的应用——两阶段终止模式

当我们在执行线程一时，想要终止线程二，这是就需要使用 interrupt 方法来优雅的停止线程二。

代码如下

public class Test {
  public static void main(String[] args) throws InterruptedException {
    Monitor monitor = new Monitor();
    monitor.start();
    Thread.sleep(3500);
    monitor.stop();
  }
}
class Monitor {
  Thread monitor;
  /**
   * 启动监控器线程
   */
  public void start() {
    //设置监控器线程，用于监控线程状态
    monitor = new Thread() {
      @Override
      public void run() {
        //开始不停的监控
        while (true) {
                    //判断当前线程是否被打断了
          if(Thread.currentThread().isInterrupted()) {
            System.out.println("处理后续任务");
                        //终止线程执行
            break;
          }
          System.out.println("监控器运行中...");
          try {
            //线程休眠
            Thread.sleep(1000);
          } catch (InterruptedException e) {
            e.printStackTrace();
            //如果是在休眠的时候被打断，不会将打断标记设置为true，这时要重新设置打断标记
            Thread.currentThread().interrupt();
          }
        }
      }
    };
    monitor.start();
  }
  /**
   *  用于停止监控器线程
   */
  public void stop() {
    //打断线程
    monitor.interrupt();
  }
}

🚁6.5 不推荐的打断方法

✨还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁。

🚁6.6 守护线程

✨默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其他非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

//将线程设置为守护线程, 默认为false
monitor.setDaemon(true);

🎉守护线程的应用场景

• 垃圾回收器就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们（Acceptor 和 Poller）处理完当前请求

🚀7. 线程状态

🚁7.1 五种状态模型

✨从操作系统层面来描述

（1）【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联

（2）【就绪状态（可运行状态）】，指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行

（3）【运行状态】，指获取了 CPU 时间片运行中的状态

当 CPU 时间片用完，会从【运行状态】转换到【可运行状态】，会导致线程的上下文切换

（4）【阻塞状态】

如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】

等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【就绪状态】

与【就绪状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

（5）【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其他状态

🚁7.2 六种状态模型

✨从 Java API 层面描述，根据 Thread.State 枚举，分为六种状态

New ：线程刚被创建，但是还没有调用 start() 方法

RUNNABLE ：当调用了 start() 方法之后（Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【就绪状态】、【运行状态】和【阻塞状态】），由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行的

BLOCKED，WAITING，TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分

TERMINATED： 当线程代码运行结束