1.3　创建线程的4种方法

1.3.1　Thread类详解

image.png

  1. 线程ID

属性：private long tid，此属性用于保存线程的ID。这是一个private类型的属性，外部只能使用getId()方法访问线程的ID。
方法：public long getId()，获取线程ID，线程ID由JVM进行管理，在进程内唯一。比如，1.2节的实例中，所输出的main线程的ID为1。

  1. 线程名称

属性：private String name，该属性保存一个Thread线程实例的名字。
方法一：public final String getName()，获取线程名称。
方法二：public final void setName(String name)，设置线程名称。
方法三：Thread(String threadName)，通过此构造方法给线程设置一个定制化的名字。

  1. 线程优先级

属性：private int priority，保存一个Thread线程实例的优先级。
方法一：public final int getPriority()，获取线程优先级。
方法二：public final void setPriority(int priority)，设置线程优先级。

Java线程的最大优先级值为10，最小值为1，默认值为5。这三个优先级值为三个常量值，在Thread类中使用类常量定义，三个类常量如下：

  1. public static final int MIN_PRIORITY = 1;
  2. public static final int NORM_PRIORITY = 5;
  3. public static final int MAX_PRIORITY = 10;
  1. 是否为守护线程

属性：private boolean daemon=false，该属性保存Thread线程实例的守护状态，默认为false，表示是普通的用户线程，而不是守护线程。
方法：public final void setDaemon(boolean on)，将线程实例标记为守护线程或用户线程，如果参数值为true，那么将线程实例标记为守护线程。

  1. 线程的状态
    1. private int threadStatus
    2. public Thread.State getState() //返回表示当前线程的执行状态，为新建、就绪、运行、阻塞、结束等状态中的一种。
    Thread的内部静态枚举类State用于定义Java线程的所有状态，具体如下： ```java public static enum State { NEW, //新建 RUNNABLE, //就绪、运行 BLOCKED, //阻塞 WAITING, //等待 TIMED_WAITING, //计时等待 TERMINATED; //结束 }
  1.     在Java线程的状态中，就绪状态和运行状态在内部用同一种状态RUNNABLE表示。就绪状态表示线程具备运行条件，正在等待获取CPU时间片；运行状态表示线程已经获取了CPU时间片，CPU正在执行线程代码逻辑。
  3. 6. 线程的启动和运行
  4. ```java
  5. public void start()
  6. public void run()
  1. start()方法用于线程的启动，run()方法作为用户代码逻辑的执行入口。

  1. 取得当前线程

    1. public static Thread currentThread()

  2. 其他的属性和方法

    1.3.2　创建一个空线程

    第一个创建线程的方法是通过继承Thread类创建一个线程实例 ```java package com.crazymakercircle.multithread.basic.create; import personal.nien.javabook.util.Print; public class EmptyThreadDemo {

    1.   public static void main(String args[]) throws InterruptedException {
    2.       //使用Thread类创建和启动线程
    3.       Thread thread = new Thread();
    4.       Print.cfo("线程名称："+thread.getName());
    5.       Print.cfo("线程ID："+thread.getId());
    6.       Print.cfo("线程状态："+thread.getState());
    7.       Print.cfo("线程优先级："+thread.getPriority());
    8.       Print.cfo(getCurThreadName() + " 运行结束.");
    9.       thread.start();
    10.   }

    }

  1.     在thread线程信息输出完成后，程序调用thread.start()实例方法启动新线程thread的执行。从上一小节大家知道，这时新线程的执行会调用Thread的run()实例方法，该方法作为用户业务代码逻辑的入口。
  2. ```java
  3. public void run() {
  4.      if(this.target != null) {
  5.          this.target.run();
  6.      }
  7. }
  1. 这里的target属性是Thread类的一个实例属性，该属性是很重要的，在后面会用到和讲到。在Thread类中，target的属性值默认为空。在这个例子中，thread线程的target属性默认为null。所以在thread线程执行时，其run()方法其实什么也没有做，线程就执行完了。

1.3.3　线程创建方法一：继承Thread类创建线程类

  1. 需要继承Thread类，创建一个新的线程类。

  2. 同时重写run()方法，将需要并发执行的业务代码编写在run()方法中。 ```java public class CreateDemo { public static final int MAX_TURN = 5; public static String getCurThreadName() {

    1.  return Thread.currentThread().getName();

    }

    static int threadNo = 1;

    static class DemoThread extends Thread {

    1.  public DemoThread() {
    2.      super("DemoThread-" + threadNo++);
    3.  }
    5.  public void run() {
    6.      for (int i = 1; i < MAX_TURN; i++) {
    7.          Print.cfo(getName() + ", 轮次：" + i);
    8.      }
    9.      Print.cfo(getName() + " 运行结束.");
    10.  }

    }

    public static void main(String[] args) {

    1.  Thread thread = null;
    3.  for (int i = 0; i < 2; i++) {
    4.      thread = new DemoThread();
    5.      thread.start();
    6.  }
    8.  Print.cfo(getCurThreadName() + " 运行结束.");

    } }

  1. <a name="qBGBz"></a>
  2. ## 1.3.4　线程创建方法二：实现Runnable接口创建线程目标类
  3. 重温一下Thread类的run()方法的代码，里边其实有点玄机，其代码如下：
  4. ```java
  5. package java.lang;
  6. public class Thread implements Runnable {
  7.      ...
  8.      private Runnable target; //执行目标
  9.      public void run() {
  10.          if(this.target != null) {
  11.                  this.target.run();  //调用执行目标的run()方法
  12.          }
  13.      }
  14.      public Thread(Runnable target) {  //包含执行目标的构造器
  15.          init(null, target, "Thread-" + nextThreadNum(), 0);
  16.      }
  17. }
  1. 在Thread类的run()方法中，如果target（执行目标）不为空，就执行target属性的run()方法。而target属性是Thread类的一个实例属性，并且target属性的类型为Runnable。<br />Thread类的target属性在什么情况下非空呢？Thread类有一系列的构造器，其中有多个构造器可以为target属性赋值，这些构造器包括如下两个：
  1. public Thread(Runnable target)
  2. public Thread(Runnable target，String name)
  1. Runnable接口

Runnable是一个极为简单的接口，位于java.lang包中。接口中只有一个方法run()，具体的源代码如下：

  1. package java.lang;
  2.  @FunctionalInterface
  3.  public interface Runnable {
  4.      void run();
  5.  }
  1. 通过实现Runnable接口创建线程类

创建线程的第二种方法就是实现Runnable接口，将需要异步执行的业务逻辑代码放在Runnable实现类的run()方法中，将Runnable实例作为target执行目标传入Thread实例。该方法的具体步骤如下：

  1. 定义一个新类实现Runnable接口。
  2. 实现Runnable接口中的run()抽象方法，将线程代码逻辑存放在该run()实现版本中。
  3. 通过Thread类创建线程对象，将Runnable实例作为实际参数传递给Thread类的构造器，由Thread构造器将该Runnable实例赋值给自己的target执行目标属性。
  4. 调用Thread实例的start()方法启动线程。

  5. 线程启动之后，线程的run()方法将被JVM执行，该run()方法将调用target属性的run()方法，从而完成Runnable实现类中业务代码逻辑的并发执行。

    1. public class CreateDemo2 {
    2.  public static final int MAX_TURN = 5;
    3.  static int threadNo = 1;
    5.  static class RunTarget implements Runnable {
    7.      @Override
    8.      public void run() {
    9.          for (int j = 1; j < MAX_TURN; j++) {
    10.              Print.cfo(ThreadUtil.getCurThreadName() + ", 轮次：" + j);
    11.          }
    12.          Print.cfo(getCurThreadName() + " 运行结束.");
    13.      }
    14.  }
    16.  public static void main(String[] args) {
    17.      Thread thread = null;
    18.      for (int i = 0; i < 2; i++) {
    19.          RunTarget runTarget = new RunTarget();
    20.          thread = new Thread(runTarget, "RunnableThread" + threadNo++);
    21.          thread.start();
    22.      }
    23.  }
    24. }

    完成了Runnable的实现类后，需要调用Thread类的构造器创建线程，并将Runnable实现类的实例作为实参传入。可以调用的构造器（即构造函数）包括如下三个：

  6. public Thread(Runnable target)

  7. public Thread(Runnable target,String name)

  8. public Thread(ThreadGroup group,Runnable target)

    1.3.5　优雅创建Runnable线程目标类的两种方式

  9. 通过匿名类优雅地创建Runnable线程目标类。

在实现Runnable编写target执行目标类时，如果target实现类是一次性类，可以使用匿名实例的形式。

  1. package com.crazymakercircle.multithread.basic.create;
  2.      // 省略import
  3.      public class CreateDemo2 {
  4.          public static final int MAX_TURN = 5;
  5.          static int threadNo = 1;
  7.          public static void main(String args[]) throws InterruptedException {
  8.              Thread thread = null;
  9.              //使用Runnable的匿名类创建和启动线程
  10.              for (int i = 0; i < 2; i++) {
  11.                  thread = new Thread(new Runnable() { //① 匿名实例
  12.                      @Override
  13.                      public void run() { //② 异步执行的业务逻辑
  14.                          for (int j = 1; j < MAX_TURN; j++) {
  15.                              Print.cfo(getCurThreadName() + ", 轮次：" + j);
  16.                          }
  17.                          Print.cfo(getCurThreadName() + " 运行结束.");
  18.                      }
  19.                  }, "RunnableThread" + threadNo++);
  20.                  thread.start();
  21.              }
  23.              Print.cfo(getCurThreadName() + " 运行结束.");
  24.          }
  25.      }

  1. 使用Lambda表达式优雅地创建Runnable线程目标类。 ```java package com.crazymakercircle.multithread.basic.create; // 省略import public class CreateDemo2 {

    1.   public static final int MAX_TURN = 5;
    2.  static int threadNo = 1;
    4.   public static void main(String args[]) throws InterruptedException {
    5.       Thread thread = null;
    6.       //使用Lambda表达式形式创建和启动线程
    7.       for (int i = 0; i < 2; i++) {
    8.           thread = new Thread( ()-> {  //①Lambda表达式
    9.                   for (int j = 1; j < MAX_TURN; j++) {
    10.                      Print.cfo(getCurThreadName() + ", 轮次：" + j); 
    11.                   }
    12.                   Print.cfo(getCurThreadName() + " 运行结束.");
    13.              }, "RunnableThread" + threadNo++); 
    14.           thread.start();
    15.       }
    17.       Print.cfo(getCurThreadName() + " 运行结束.");
    18.   }

    }

  1. <a name="QnN5E"></a>
  2. ## 1.3.6　通过实现Runnable接口的方式创建线程目标类的优缺点
  3. 通过实现Runnable接口的方式创建线程目标类有以下缺点：
  5. 1. 所创建的类并不是线程类，而是线程的target执行目标类，需要将其实例作为参数传入线程类的构造器，才能创建真正的线程。
  6. 1. 如果访问当前线程的属性（甚至控制当前线程），不能直接访问Thread的实例方法，必须通过Thread.currentThread()获取当前线程实例，才能访问和控制当前线程。
  8. 通过实现Runnable接口的方式创建线程目标类有以下优点：
  10. 1. 可以避免由于Java单继承带来的局限性。如果异步逻辑所在类已经继承了一个基类，就没有办法再继承Thread类。比如，当一个Dog类继承了Pet类，再要继承Thread类就不行了。所以在已经存在继承关系的情况下，只能使用实现Runnable接口的方式。
  11. 1. 逻辑和数据更好分离。通过实现Runnable接口的方法创建多线程更加适合同一个资源被多段业务逻辑并行处理的场景。在同一个资源被多个线程逻辑异步、并行处理的场景中，通过实现Runnable接口的方式设计多个target执行目标类可以更加方便、清晰地将执行逻辑和数据存储分离，更好地体现了面向对象的设计思想。
  13. - “逻辑和数据更好地分离”演示实例
  14. ```java
  15. public class SalesDemo {
  16.     public static final int MAX_AMOUNT = 5; //商品数量
  18.     //商店商品类（销售线程类），一个商品一个销售线程，每个线程异步销售4次
  19.     static class StoreGoods extends Thread {
  20.         StoreGoods(String name) {
  21.             super(name);
  22.         }
  24.         private int goodsAmount = MAX_AMOUNT;
  26.         public void run() {
  27.             for (int i = 0; i < MAX_AMOUNT; i++) {
  28.                 if (this.goodsAmount > 0) {
  29.                     Print.cfo(getCurThreadName() + " 卖出一件，还剩：" + (--goodsAmount));
  30.                     sleepMilliSeconds(10);
  31.                 }
  32.             }
  33.             Print.cfo(getCurThreadName() + " 运行结束.");
  34.         }
  35.     }
  37.     //商场商品类（target销售线程的目标类），一个商品最多销售4次，可以多人销售
  38.     static class MallGoods implements Runnable {
  39.         //多人销售可能导致数据出错，使用原子数据类型保障数据安全
  40.         private AtomicInteger goodsAmount = new AtomicInteger(MAX_AMOUNT);
  42.         public void run() {
  43.             for (int i = 0; i <= MAX_AMOUNT; i++) {
  44.                 if (this.goodsAmount.get() > 0) {
  45.                     Print.cfo(getCurThreadName() + " 卖出一件，还剩："
  46.                             + (goodsAmount.decrementAndGet()));
  47.                     sleepMilliSeconds(10);
  48.                 }
  49.             }
  50.             Print.cfo(getCurThreadName() + " 运行结束.");
  51.         }
  52.     }
  54.     public static void main(String args[]) throws InterruptedException {
  55.         Print.hint("商店版本的销售");
  56.         for (int i = 1; i <= 2; i++) {
  57.             Thread thread = null;
  58.             thread = new StoreGoods("店员-" + i);
  59.             thread.start();
  60.         }
  62.         Thread.sleep(1000);
  63.         Print.hint("商场版本的销售");
  64.         MallGoods mallGoods = new MallGoods();
  65.         for (int i = 1; i <= 2; i++) {
  66.             Thread thread = null;
  67.             thread = new Thread(mallGoods, "商场销售员-" + i);
  68.             thread.start();
  69.         }
  70.         Print.cfo(getCurThreadName() + " 运行结束.");
  71.     }
  72. }
  1. 通过继承Thread类实现多线程能更好地做到多个线程并发地完成各自的任务，访问各自的数据资源。
  2. 通过实现Runnable接口实现多线程能更好地做到多个线程并发地完成同一个任务，访问同一份数据资源。多个线程的代码逻辑可以方便地访问和处理同一个共享数据资源（如例子中的MallGoods.goodsAmount），这样可以将线程逻辑和业务数据进行有效的分离，更好地体现了面向对象的设计思想。

  3. 通过实现Runnable接口实现多线程时，如果数据资源存在多线程共享的情况，那么数据共享资源需要使用原子类型（而不是普通数据类型），或者需要进行线程的同步控制，以保证对共享数据操作时不会出现线程安全问题。

    1.3.7　线程创建方法三：使用Callable和FutureTask创建线程

    前面已经介绍了继承Thread类或者实现Runnable接口这两种方式来创建线程类，但是这两种方式有一个共同的缺陷：不能获取异步执行的结果。
    为了解决异步执行的结果问题，Java语言在1.5版本之后提供了一种新的多线程创建方法：通过Callable接口和FutureTask类相结合创建线程。

  4. Callable接口 ```java package java.util.concurrent; @FunctionalInterface public interface Callable {

    1.   V call() throws Exception;

    }

  2. 2. RunnableFuture接口
  3. ```java
  4. package java.util.concurrent;
  6.      public interface RunnableFuture<V>  extends  Runnable, Future<V> {
  7.          void run();
  8.      }
  1. RunnableFuture继承了Runnable接口，从而保证了其实例可以作为Thread线程实例的target目标；同时，RunnableFuture通过继承Future接口，保证了可以获取未来的异步执行结果。
  1. Future接口
  • 能够取消异步执行中的任务。
  • 判断异步任务是否执行完成。
  • 获取异步任务完成后的执行结果。 ```java package java.util.concurrent; public interface Future {
    1.    boolean cancel(boolean mayInterruptRunning); //取消异步执行
    2.    boolean isCancelled();
    3.    boolean isDone();//判断异步任务是否执行完成
    4.    //获取异步任务完成后的执行结果
    5.    V get() throws InterruptedException, ExecutionException;
    6.    //设置时限，获取异步任务完成后的执行结果
    7.    V get(long timeout, TimeUnit unit) throws InterruptedException, 
    8.                                          ExecutionException, TimeoutException;
    9.   ...
    }
  2. 4. FutureTask类
  4. FutureTask类才是真正的在Thread与Callable之间搭桥的类。
  6. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/27178439/1649937555089-b0ce1cf5-3c99-4e57-8d35-9d5c6d62c4fc.png#clientId=ue9b87c13-8f16-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=441&id=u573dbd07&margin=%5Bobject%20Object%5D&name=image.png&originHeight=551&originWidth=575&originalType=binary&ratio=1&rotation=0&showTitle=false&size=86442&status=done&style=none&taskId=u4a270b74-8bbc-4498-bf2a-32c7555a843&title=&width=460)<br />FutureTask的outcome实例属性用于保存callable成员call()方法的异步执行结果。在FutureTask类的run()方法完成callable成员的call()方法的执行之后，其结果将被保存在outcome实例属性中，供FutureTask类的get()方法获取。
  8. 5. 使用Callable和FutureTask创建线程的具体步骤
  9.    1. 创建一个Callable接口的实现类，并实现其call()方法，编写好异步执行的具体逻辑，可以有返回值。
  10.    1. 使用Callable实现类的实例构造一个FutureTask实例。
  11.    1. 使用FutureTask实例作为Thread构造器的target入参，构造新的Thread线程实例。
  12.    1. 调用Thread实例的start()方法启动新线程，启动新线程的run()方法并发执行。其内部的执行过程为：启动Thread实例的run()方法并发执行后，会执行FutureTask实例的run()方法，最终会并发执行Callable实现类的call()方法。
  13.    1. 调用FutureTask对象的get()方法阻塞性地获得并发线程的执行结果。
  14. ```java
  15. package com.crazymakercircle.multithread.basic.create;
  16.      // 省略import
  17.      public class CreateDemo3 {
  18.          public static final int MAX_TURN = 5;
  19.          public static final int COMPUTE_TIMES = 100000000;
  21.      //①创建一个 Callable 接口的实现类
  22.          static class ReturnableTask implements Callable<Long> {
  23.               //②编写好异步执行的具体逻辑，可以有返回值
  24.               public Long call() throws Exception{
  25.                  long startTime = System.currentTimeMillis();
  26.                  Print.cfo(getCurThreadName() + " 线程运行开始.");
  27.                  Thread.sleep(1000);
  29.                  for (int i = 0; i < COMPUTE_TIMES; i++) {
  30.                      int j = i * 10000;
  31.                  }
  32.                  long used = System.currentTimeMillis() - startTime;
  33.                  Print.cfo(getCurThreadName() + " 线程运行结束.");
  34.                  return used;
  35.              }
  36.          }
  38.          public static void main(String args[]) throws InterruptedException {
  39.              ReturnableTask task=new ReturnableTask();//③
  40.              FutureTask<Long> futureTask = new FutureTask<Long>(task);//④
  41.              Thread thread = new Thread(futureTask, "returnableThread");//⑤
  42.              thread.start();//⑥
  43.              Thread.sleep(500);
  44.              Print.cfo(getCurThreadName() + " 让子弹飞一会儿.");
  45.              Print.cfo(getCurThreadName() + " 做一点自己的事情.");
  46.              for (int i = 0; i < COMPUTE_TIMES / 2; i++) {  int j = i * 10000;
  47.              }
  49.              Print.cfo(getCurThreadName() + " 获取并发任务的执行结果.");
  50.              try {
  51.                  Print.cfo(thread.getName()+"线程占用时间："
  52.                                           + futureTask.get());//⑦
  53.              } catch (InterruptedException e) {
  54.                  e.printStackTrace();
  55.              } catch (ExecutionException e) {
  56.                  e.printStackTrace();
  57.              }
  58.              Print.cfo(getCurThreadName() + " 运行结束.");
  59.          }
  60.      }

image.png

1.3.8　线程创建方法四：通过线程池创建线程

  1. 线程池的创建与执行目标提交
    1. //创建一个包含三个线程的线程池
    2. private static ExecutorService pool = Executors.newFixedThreadPool(3);
    向ExecutorService线程池提交异步执行target目标任务的常用方法有： ```java //方法一：执行一个 Runnable类型的target执行目标实例，无返回 void execute(Runnable command);

//方法二：提交一个 Callable类型的target执行目标实例, 返回一个Future异步任务实例

Future submit(Callable task);

//方法三：提交一个 Runnable类型的target执行目标实例, 返回一个Future异步任务实例 Future<?> submit(Runnable task);

  2. 2. 线程池的使用实战
  3. ```java
  4. public class CreateDemo4 {
  5.     public static final int MAX_TURN = 5;
  6.     public static final int COMPUTE_TIMES = 100000000;
  8.     //创建一个包含三个线程的线程池
  9.     private static ExecutorService pool = Executors.newFixedThreadPool(3);
  11.     static class DemoThread implements Runnable {
  13.         @Override
  14.         public void run() {
  15.             for (int j = 1; j < MAX_TURN; j++) {
  16.                 Print.cfo(getCurThreadName() + ", 轮次：" + j);
  17.                 sleepMilliSeconds(10);
  18.             }
  19.         }
  20.     }
  22.     static class ReturnableTask implements Callable<Long> {
  24.         @Override
  25.         public Long call() throws Exception {
  26.             long startTime = System.currentTimeMillis();
  27.             Print.cfo(getCurThreadName() + " 线程运行开始.");
  28.             for (int j = 1; j < MAX_TURN; j++) {
  29.                 Print.cfo(getCurThreadName() + ", 轮次：" + j);
  30.                 sleepMilliSeconds(10);
  31.             }
  32.             long used = System.currentTimeMillis() - startTime;
  33.             Print.cfo(getCurThreadName() + " 线程运行结束.");
  34.             return used;
  35.         }
  36.     }
  38.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  39.         pool.execute(new DemoThread()); //执行线程实例，无返回
  40.         pool.execute(new Runnable() {
  41.             @Override
  42.             public void run() {
  43.                 for (int j = 1; j < MAX_TURN; j++) {
  44.                     Print.cfo(getCurThreadName() + ", 轮次：" + j);
  45.                     sleepMilliSeconds(10);
  46.                 }
  47.             }
  48.         });
  49.         //提交Callable 执行目标实例，有返回
  50.         Future future = pool.submit(new ReturnableTask());
  51.         Long result = (Long) future.get();
  52.         Print.cfo("异步任务的执行结果为：" + result);
  53.     }
  54. }

ExecutorService线程池的execute(…)与submit(…)方法的区别如下。

  1. 接收的参数不一样
  2. submit()有返回值，而execute()没有

    1.4　线程的核心原理

    1.4.1　线程的调度与时间片

    1.4.2　线程的优先级

    在Thread类中有一个实例属性和两个实例方法，专门用于进行线程优先级相关的操作。 ```java private int priority；//该属性保存一个Thread实例的优先级，即1～10的值 public final int getPriority(); public final void setPriority(int priority);
  1. Thread实例的priority属性默认是级别5，对应的类常量是NORM_PRIORITY。优先级最大值为10，最小值为1，Thread类中定义的三个优先级常量如下：
  2. ```java
  3. public static final int MIN_PRIORITY = 1;
  4. public static final int NORM_PRIORITY = 5;
  5. public static final int MAX_PRIORITY = 10;

Java中使用抢占式调度模型进行线程调度。priority实例属性的优先级越高，线程获得CPU时间片的机会就越多，但也不是绝对的。举一个例子，顺便演示以上两个线程优先级实例方法的使用，具体如下：

  1. package com.crazymakercircle.multithread.basic.create2;
  2.      import personal.nien.javabook.util.Print;
  3.      public class PriorityDemo {
  4.          public static final int SLEEP_GAP = 1000;
  5.              static class PrioritySetThread extends Thread {
  6.              static int threadNo = 1;
  7.              public PrioritySetThread() {
  8.                  super("thread-" + threadNo);
  9.                  threadNo++;
  10.              }
  12.              public long opportunities=0;
  13.              public void run() {
  14.                  for (int i = 0; ; i++) {
  15.                      opportunities++;
  16.                  }
  17.              }
  18.          }
  20.          public static void main(String args[]) throws InterruptedException {
  22.              PrioritySetThread[] threads=new PrioritySetThread[10];
  23.              for (int i = 0; i < threads.length; i++) {
  24.                  threads[i]=new PrioritySetThread();
  25.                  //优先级的设置，1～10
  26.                  threads[i].setPriority(i+1);
  27.              }
  29.              for (int i = 0; i < threads.length; i++) {
  30.                  threads[i].start();//启动线程
  31.              }
  33.              Thread.sleep(SLEEP_GAP); //等待线程运行1s
  35.              for (int i = 0; i < threads.length; i++) {
  36.                  threads[i].stop(); //停止线程
  37.              }
  39.              for (int i = 0; i < threads.length; i++) {
  40.                  Print.cfo(threads[i].getName()+
  41.                          "-优先级为-"+threads[i].getPriority()+ //获取优先级
  42.                          "-机会值为-"+threads[i].opportunities
  43.                         );
  44.               }
  46.          }
  47.      }
  1. 整体而言，高优先级的线程获得的执行机会更多。从实例中可以看到：优先级在6级以上的线程和4级以下的线程执行机会明显偏多，整体对比非常明显
  2. 执行机会的获取具有随机性，优先级高的不一定获得的机会多。比如，例子中的thread-10比thread-9优先级高，但是thread-10所获得的机会反而偏少。

    1.4.3　线程的生命周期

    Java中线程的生命周期分为6种状态。Thread类有一个实例属性和一个实例方法专门用于保存和获取线程的状态。 ```java private int threadStatus；//以整数的形式保存线程的状态 public Thread.State getState(); //返回当前线程的执行状态，一个枚举类型值 public static enum State {
    1.   NEW,                               //新建
    2.   RUNNABLE,                  //可执行：包含操作系统的就绪、运行两种状态
    3.   BLOCKED,                   //阻塞
    4.   WAITING,                   //等待
    5.   TIMED_WAITING,             //限时等待
    6.   TERMINATED;                //终止
    }
  2. 1. NEW状态
  4. 创建成功但是没有调用start()方法启动的Thread线程实例都处于NEW状态。
  6. 2. RUNNABLE状态
  8. NEW状态的Thread实例调用了start()方法后，线程的状态将变成RUNNABLE状态。尽管如此，线程的run()方法不一定会马上被并发执行，需要在线程获取了CPU时间片之后才真正启动并发执行。
  10. 3. TERMINATED状态
  12. 处于RUNNABLE状态的线程在run()方法执行完成之后就变成终止状态TERMINATED了。当然，如果在run()方法执行过程中发生了运行时异常而没有被捕获，run()方法将被异常终止，线程也会变成TERMINATED状态。
  14. 4. TIMED_WAITING状态
  16. 线程处于一种特殊的等待状态，准确地说，线程处于限时等待状态。能让线程处于限时等待状态的操作大致有以下几种：<br />a. Thread.sleep(int n)：使得当前线程进入限时等待状态，等待时间为n毫秒。<br />b. Object.wait()：带时限的抢占对象的monitor锁。<br />c. Thread.join()：带时限的线程合并。<br />d. LockSupport.parkNanos()：让线程等待，时间以纳秒为单位。<br />e. LockSupport.parkUntil()：让线程等待，时间可以灵活设置。
  17. <a name="iiDb5"></a>
  18. ## 1.4.4　一个线程状态的简单演示案例
  19. ```java
  20. public class StatusDemo {
  22.     //每个线程执行的轮次
  23.     public static final long MAX_TURN = 5;
  25.     //线程编号
  26.     static int threadSeqNumber = 0;
  28.     //全局的静态线程列表
  29.     static List<Thread> threadList = new ArrayList<>();
  31.     //输出静态线程列表中每个线程的状态
  32.     private static void printThreadStatus() {
  33.         for (Thread thread : threadList) {
  34.             Print.tco(thread.getName() + " 状态为 " + thread.getState());
  36.         }
  37.     }
  39.     //向全局的静态线程列表加入线程
  40.     private static void addStatusThread(Thread thread) {
  41.         threadList.add(thread);
  42.     }
  44.     static class StatusDemoThread extends Thread {
  45.         public StatusDemoThread() {
  46.             super("statusPrintThread" + (++threadSeqNumber));
  47.             //将自己加入全局的静态线程列表
  48.             addStatusThread(this);
  49.         }
  51.         public void run() {
  52.             Print.cfo(getName() + ", 状态为" + getState());
  53.             for (int turn = 0; turn < MAX_TURN; turn++) {
  54.                 //线程睡眠
  55.                 sleepMilliSeconds(500);
  56.                 //输出所有线程的状态
  57.                 printThreadStatus();
  58.             }
  59.             Print.tco(getName() + "- 运行结束.");
  60.         }
  61.     }
  63.     public static void main(String args[]) throws InterruptedException {
  64.         //将main线程加入全局列表
  65.         addStatusThread(Thread.currentThread());
  66.         //新建三个线程，这些线程在构造器中会将自己加入全局列表
  67.         Thread sThread1 = new StatusDemoThread();
  68.         Print.cfo(sThread1.getName() + "- 状态为" + sThread1.getState());
  69.         Thread sThread2 = new StatusDemoThread();
  70.         Print.cfo(sThread2.getName() + "- 状态为" + sThread2.getState());
  71.         Thread sThread3 = new StatusDemoThread();
  72.         Print.cfo(sThread3.getName() + "- 状态为" + sThread3.getState());
  74.         sThread1.start();              //启动第一个线程
  76.         sleepMilliSeconds(500);        //等待500毫秒启动第二个线程
  77.         sThread2.start();
  79.         sleepMilliSeconds(500);        //等待1000毫秒启动第三个线程
  80.         sThread3.start();
  82.         sleepSeconds(100);             //睡眠100秒
  83.     }
  84. }

对于示例中调用的sleepMilliSeconds()方法，它的内部调用了LockSupport.parkNanos(…)方法使得当前线程限时等待，这是为了编程快捷而自定义的方法，其代码如下：

  1. package com.crazymakercircle.util;
  2.      // 省略import
  3.      public class ThreadUtil
  4.      {
  6.          public static void sleepMilliSeconds(int millisecond)
  7.          {
  8.              LockSupport.parkNanos(millisecond * 1000L * 1000L);
  9.          }
  10.          // 省略其他方法
  11.      }

1.4.5　使用Jstack工具查看线程状态

1.5　线程的基本操作

1.5.1　线程名称的设置和获取

  1. public class ThreadNameDemo {
  2.     private static final int MAX_TURN = 3;
  4.     //异步执行目标类
  5.     static class RunTarget implements Runnable {    // 实现Runnable接口
  6.         public void run() {    // 重新run()方法
  7.             for (int turn = 0; turn < MAX_TURN; turn++) {
  8.                 sleepMilliSeconds(500);//线程睡眠
  9.                 Print.tco("线程执行轮次:" + turn);
  10.             }
  11.         }
  12.     }
  14.     public static void main(String args[]) {
  15.         RunTarget target = new RunTarget();    // 实例化Runnable异步执行目标类
  16.         new Thread(target).start();        // 系统自动设置线程名称
  17.         new Thread(target).start();        // 系统自动命令线程名称
  18.         new Thread(target).start();        // 系统自动命令线程名称
  19.         new Thread(target, "手动命名线程-A").start();        // 手动设置线程名称
  20.         new Thread(target, "手动命名线程-B").start();        // 手动设置线程名称
  21.         sleepSeconds(Integer.MAX_VALUE); //主线程不能结束
  22.     }
  23. }

Print.tco()方法的代码如下

  1. package com.crazymakercircle.util;
  2.      public class Print
  3.      {
  4.          /**
  5.           * 在正式输出的内容前输出线程的名称
  6.           * @param s 待输出的字符串
  7.           */
  8.          public static void tco(Object s)
  9.          {
  10.              String cft = "[" + Thread.currentThread().getName() + "]" + "：" + s;
  11.              //提交线程池进行异步输出，使得输出过程不影响当前线程的执行
  12.              //异步输出的好处：不会造成输出乱序，也不会造成当前线程阻塞
  13.              ThreadUtil.execute(() ->
  14.              {
  15.                  synchronized (System.out)
  16.                  {
  17.                      System.out.println(cft);
  18.                  }
  19.              });
  20.          }
  21.          //省去不相干的代码
  22.      }

1.5.2　线程的sleep操作

Sleep()方法定义在Thread类中，是一组静态方法，有两个重载版本：

  1. //使目前正在执行的线程休眠millis毫秒
  2. public static void sleep(long millis) throws InterruptException；
  4. //使目前正在执行的线程休眠millis毫秒，nanos纳秒
  5. public static void sleep(long millis，int nanos) throws InterruptException；

举一个例子演示一下sleep()静态方法的调用，具体如下：

  1. public class SleepDemo {
  3.     public static final int SLEEP_GAP = 5000;//睡眠时长
  4.     public static final int MAX_TURN = 50;//睡眠次数
  6.     static class SleepThread extends Thread {
  7.         static int threadSeqNumber = 1;
  9.         public SleepThread() {
  10.             super("sleepThread-" + threadSeqNumber);
  11.             threadSeqNumber++;
  12.         }
  14.         public void run() {
  15.             try {
  16.                 for (int i = 1; i < MAX_TURN; i++) {
  17.                     Print.tco(getName() + ", 睡眠轮次：" + i);
  18.                     // 线程睡眠一会
  19.                     Thread.sleep(SLEEP_GAP);
  20.                 }
  21.             } catch (InterruptedException e) {
  22.                 Print.tco(getName() + " 发生异常被中断.");
  24.             }
  25.             Print.tco(getName() + " 运行结束.");
  26.         }
  28.     }
  30.     public static void main(String args[]) throws InterruptedException {
  31.         for (int i = 0; i < 5; i++) {
  32.             Thread thread = new SleepThread();
  33.             thread.start();
  34.         }
  35.         Print.tco(getCurThreadName() + " 运行结束.");
  36.     }
  37. }
  1. C:\Users\user>jps
  2.      8468 Jps
  3.      18024 SleepDemo
  5.  C:\Users\user>jstack 18024
  6.  // 省略不相干的输出
  7.  "sleepThread-4" #17 prio=5 os_prio=0 tid=0x000000001fd21800 nid=0x462c waiting on condition [0x0000000020cbf000]
  8.     java.lang.Thread.State: TIMED_WAITING (sleeping)
  9.          at java.lang.Thread.sleep(Native Method)
  10.          at ...SleepDemo$SleepThread.run(SleepDemo.java:35)
  12.  "sleepThread-3" #16 prio=5 os_prio=0 tid=0x000000001fd1e800 nid=0x28a4 waiting on condition [0x0000000020bbf000]
  13.     java.lang.Thread.State: TIMED_WAITING (sleeping)
  14.          at java.lang.Thread.sleep(Native Method)
  15.          at ...SleepDemo$SleepThread.run(SleepDemo.java:35)
  17.  "sleepThread-2" #15 prio=5 os_prio=0 tid=0x000000001fd1e000 nid=0x1264 waiting on condition [0x0000000020abf000]
  18.     java.lang.Thread.State: TIMED_WAITING (sleeping)
  19.          at java.lang.Thread.sleep(Native Method)
  20.          at ...SleepDemo$SleepThread.run(SleepDemo.java:35)
  22.  "sleepThread-1" #14 prio=5 os_prio=0 tid=0x000000001fd29000 nid=0x1914 waiting on condition [0x00000000209be000]
  23.     java.lang.Thread.State: TIMED_WAITING (sleeping)
  24.          at java.lang.Thread.sleep(Native Method)
  25.          at ...SleepDemo$SleepThread.run(SleepDemo.java:35)

1.5.3　线程的interrupt操作

一个线程什么时候可以退出呢？当然只有线程自己才能知道。所以，这里介绍一下Thread的interrupt()方法，此方法本质不是用来中断一个线程，而是将线程设置为中断状态。

  1. public class InterruptDemo {
  3.     public static final int SLEEP_GAP = 5000;//睡眠时长
  4.     public static final int MAX_TURN = 50;//睡眠次数
  6.     static class SleepThread extends Thread {
  7.         static int threadSeqNumber = 1;
  9.         public SleepThread() {
  10.             super("sleepThread-" + threadSeqNumber);
  11.             threadSeqNumber++;
  12.         }
  14.         public void run() {
  15.             try {
  16.                 Print.tco(getName() + " 进入睡眠.");
  17.                 // 线程睡眠一会
  18.                 Thread.sleep(SLEEP_GAP);
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.                 Print.tco(getName() + " 发生被异常打断.");
  22.                 return;
  23.             }
  24.             Print.tco(getName() + " 运行结束.");
  25.         }
  27.     }
  29.     public static void main(String args[]) throws InterruptedException {
  31.         Thread thread1 = new SleepThread();
  32.         thread1.start();
  33.         Thread thread2 = new SleepThread();
  34.         thread2.start();
  35.         sleepSeconds(2);//等待2秒
  36.         thread1.interrupt(); //打断线程1
  37.         sleepSeconds(5);//等待5秒
  38.         thread2.interrupt();  //打断线程2，此时线程2已经终止
  39.         sleepSeconds(1);//等待1秒
  40.         Print.tco("程序运行结束.");
  41.     }
  42. }

下面的示例程序演示如何调用isInterrupted()实例方法监视线程的中断状态，如果发现线程被中断，就进行相应的处理，具体的代码如下：

  1. package com.crazymakercircle.multithread.basic.use;
  2.      // 省略import
  3.      public class InterruptDemo
  4.      {
  6.          //测试用例：获取异步调用的结果
  7.          @Test
  8.          public void testInterrupted2()
  9.          {
  10.              Thread thread = new Thread()
  11.              {
  12.                  public void run()
  13.                  {
  14.                      Print.tco("线程启动了");
  15.                      //一直循环
  16.                      while (true)
  17.                      {
  18.                          Print.tco(isInterrupted());
  19.                          sleepMilliSeconds(5000);
  21.                          //如果线程被中断，就退出死循环
  22.                          if (isInterrupted())    
  23.                          {
  24.                              Print.tco("线程结束了");
  25.                              return;
  26.                          }
  27.                      }
  28.                  }
  29.              };
  30.              thread.start();
  31.              sleepSeconds(2);                       //等待2秒
  32.              thread.interrupt();            //中断线程
  33.              sleepSeconds(2);                       //等待2秒
  34.              thread.interrupt();
  35.          }
  36.      }

1.5.4　线程的join操作

  1. 线程的join操作的三个版本 ```java //重载版本1：此方法会把当前线程变为TIMED_WAITING，直到被合并线程执行结束 public final void join() throws InterruptedException：

//重载版本2：此方法会把当前线程变为TIMED_WAITING，直到被合并线程执行结束，或者等待被合并线程执行millis的时间 public final synchronized void join(long millis) throws InterruptedException：

//重载版本3：此方法会把当前线程变为TIMED_WAITING，直到被合并线程执行结束，或者等待被合并线程执行millis+nanos的时间 public final synchroinzed void join(long millis, int nanos) throws InterruptedException：

  2. 2. 线程的join操作的演示实例
  3. ```java
  4. package com.crazymakercircle.multithread.basic.use;
  5.      // 省略import
  6.      public class JoinDemo
  7.      {
  9.          public static final int SLEEP_GAP = 5000;//睡眠时长
  10.          public static final int MAX_TURN = 50;//睡眠次数
  12.          static class SleepThread extends Thread
  13.          {
  14.             // 省略SleepThread的代码，执行时睡眠5秒
  15.             // 具体代码与上一小节的SleepThread内部类相同，也可以参考随书源码
  16.          }
  18.          public static void main(String args[])
  19.          {
  20.              Thread thread1 = new SleepThread();
  21.              Print.tco("启动 thread1.");
  22.              thread1.start();
  23.              try
  24.              {
  25.                  thread1.join();//合并线程1，不限时
  26.              } catch (InterruptedException e)
  27.              {
  28.                  e.printStackTrace();
  29.              }
  30.              Print.tco("启动 thread2.");
  31.              //启动第二条线程，并且进行限时合并，等待时间为1秒
  32.              Thread thread2 = new SleepThread();
  33.              thread2.start();
  34.              try
  35.              {
  36.                  thread2.join(1000);//限时合并，限时1秒
  37.              } catch (InterruptedException e)
  38.              {
  39.                  e.printStackTrace();
  40.              }
  41.              Print.tco("线程运行结束.");
  42.          }
  43.      }
  1. join线程的WAITING状态

  2. join线程的TIMED_WAITING状态

    1.5.5　线程的yield操作

    线程的yield（让步）操作的作用是让目前正在执行的线程放弃当前的执行，让出CPU的执行权限，使得CPU去执行其他的线程。
    yield()方法是Thread类提供的一个静态方法，它可以让当前正在执行的线程暂停，但它不会阻塞该线程，只是让线程转入就绪状态。yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，yield()方法只有一个版本： ```java package com.crazymakercircle.multithread.basic.use; // 省略import public class YieldDemo {

    1.   public static final int MAX_TURN = 100;//执行次数
    2.   public static AtomicInteger index = new AtomicInteger(0);//执行编号
    4.   // 记录线程的执行次数
    5.   private static Map<String, AtomicInteger> metric = new HashMap<>();
    7.   //输出线程的执行次数
    8.   private static void printMetric()
    9.   {
    10.       Print.tco("metric = " + metric);
    11.   }
    13.   static class YieldThread extends Thread
    14.   {
    15.       static int threadSeqNumber = 1;
    16.       public YieldThread()
    17.       {
    18.           super("sleepThread-" + threadSeqNumber);
    19.           threadSeqNumber++;
    20.               //将线程加入执行次数统计map
    21.           metric.put(this.getName(), new AtomicInteger(0));
    22.       }
    24.       public void run()
    25.       {
    26.           for (int i = 1; i < MAX_TURN && index.get() < MAX_TURN; i++)
    27.           {
    28.               Print.tco("线程优先级：" + getPriority());
    29.               index.incrementAndGet();
    30.               //统计一次
    31.               metric.get(this.getName()).incrementAndGet();
    32.               if (i % 2 == 0)
    33.               {
    34.                  //让步：出让执行的权限
    35.                   Thread.yield();
    36.               }
    37.           }
    38.          //输出所有线程的执行次数
    39.           printMetric();
    40.           Print.tco(getName() + " 运行结束.");
    41.       }
    42.   }
    44.   @Test
    45.   public void test()
    46.   {
    47.       Thread thread1 = new YieldThread();
    48.         //设置为最高的优先级
    49.       thread1.setPriority(Thread.MAX_PRIORITY);
    50.       Thread thread2 = new YieldThread();
    51.         //设置为最低的优先级
    52.       thread2.setPriority(Thread.MIN_PRIORITY);
    53.       Print.tco("启动线程.");
    54.       thread1.start();
    55.       thread2.start();
    56.       sleepSeconds(100);
    57.   }

    }

  1. 总结起来，Thread.yeid()方法有以下特点：<br />（1）yield仅能使一个线程从运行状态转到就绪状态，而不是阻塞状态。<br />（2）yield不能保证使得当前正在运行的线程迅速转换到就绪状态。<br />（3）即使完成了迅速切换，系统通过线程调度机制从所有就绪线程中挑选下一个执行线程时，就绪的线程有可能被选中，也有可能不被选中，其调度的过程受到其他因素（如优先级）的影响。
  2. <a name="Y3vdO"></a>
  3. ## 1.5.6　线程的daemon操作
  5. 1. 守护线程的基本操作
  6. 1. 守护线程的基本操作演示实例
  7. ```java
  8. package com.crazymakercircle.multithread.basic.use;
  9.      // 省略import
  10.      public class DaemonDemo
  11.      {
  12.          public static final int SLEEP_GAP = 500; //每一轮的睡眠时长
  13.          public static final int MAX_TURN = 4; //用户线程执行轮次
  15.          //守护线程实现类
  16.          static class DaemonThread extends Thread
  17.          {
  18.              public DaemonThread()
  19.              {
  20.                  super("daemonThread");
  21.              }
  22.              public void run()
  23.              {
  24.                  Print.synTco("--daemon线程开始.");
  25.                  for (int i = 1; ; i++)     //死循环
  26.                  {
  27.                      Print.synTco("--轮次：" + i);
  28.                      Print.synTco("--守护状态为:" + isDaemon());
  29.                      // 线程睡眠一会，500毫秒
  30.                      sleepMilliSeconds(SLEEP_GAP);
  31.                  }
  32.              }
  33.          }
  35.          public static void main(String args[]) throws InterruptedException
  36.          {
  38.              Thread daemonThread = new DaemonThread();
  39.              daemonThread.setDaemon(true);
  40.              daemonThread.start();
  42.              //创建一条用户线程，执行4轮
  43.              Thread userThread = new Thread(() ->
  44.              {
  45.                  Print.synTco(">>用户线程开始.");
  46.                  for (int i = 1; i <= MAX_TURN; i++)
  47.                  {
  48.                      Print.synTco(">>轮次：" + i);
  49.                      Print.synTco(">>守护状态为:" + getCurThread().isDaemon());
  50.                      sleepMilliSeconds(SLEEP_GAP);
  51.                  }
  52.                  Print.synTco(">>用户线程结束.");
  53.              }, "userThread");
  55.              //启动用户线程        
  56.              userThread.start();
  58.              Print.synTco(" 守护状态为:" + getCurThread().isDaemon());
  59.              Print.synTco(" 运行结束.");
  60.          }
  61.      }
  1. 守护线程与用户线程的关系

从是否为守护线程的角度，对Java线程进行分类，分为用户线程和守护线程。守护线程和用户线程的本质区别是：二者与JVM虚拟机进程终止的方向不同。用户线程和JVM进程是主动关系，如果用户线程全部终止，JVM虚拟机进程也随之终止；守护线程和JVM进程是被动关系，如果JVM进程终止，所有的守护线程也随之终止，
image.png

  1. 守护线程的要点
  • 守护线程必须在启动前将其守护状态设置为true，启动之后不能再将用户线程设置为守护线程，否则JVM会抛出一个InterruptedException异常。
  • 守护线程存在被JVM强行终止的风险，所以在守护线程中尽量不去访问系统资源，如文件句柄、数据库连接等。
  • 守护线程创建的线程也是守护线程。

  1. 守护线程创建的线程也是守护线程

    1.5.7　线程状态总结

  2. NEW状态

  3. RUNNABLE状态
  4. BLOCKED状态
  5. WAITING状态
  6. TIMED_WAITING状态

  7. TERMINATED状态

    1.6　线程池原理与实战

    1.6.1　JUC的线程池架构

    image.png

  8. Executor

Executor是Java异步目标任务的“执行者”接口，其目标是执行目标任务。“执行者”Executor提供了execute()接口来执行已提交的Runnable执行目标实例。Executor作为执行者的角色，其目的是提供一种将“任务提交者”与“任务执行者”分离开来的机制。

  1. ExecutorService

ExecutorService继承于Executor。它是Java异步目标任务的“执行者服务接”口，对外提供异步任务的接收服务。ExecutorService提供了“接收异步任务并转交给执行者”的方法，如submit系列方法、invoke系列方法等，具体如下：

  1. //向线程池提交单个异步任务
  2. <T> Future<T> submit(Callable<T> task);
  3. //向线程池提交批量异步任务
  4. <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
  1. AbstractExecutorService

AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。AbstractExecutorService存在的目的是为ExecutorService中的接口提供默认实现。

  1. ThreadPoolExecutor

ThreadPoolExecutor就是大名鼎鼎的“线程池”实现类，它继承于AbstractExecutorService抽象类。

  1. ScheduledExecutorService

ScheduledExecutorService是一个接口，它继承于ExecutorService。它是一个可以完成“延时”和“周期性”任务的调度线程池接口，其功能和Timer/TimerTask类似。

  1. ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor继承于ThreadPoolExecutor，它提供了ScheduledExecutorService线程池接口中“延时执行”和“周期执行”等抽象调度方法的具体实现。

  1. Executors

Executors是一个静态工厂类，它通过静态工厂方法返回ExecutorService、ScheduledExecutorService等线程池示例对象，这些静态工厂方法可以理解为一些快捷的创建线程池的方法。

1.6.2　Executors的4种快捷创建线程池的方法

image.png

  1. newSingleThreadExecutor创建“单线程化线程池”

该方法用于创建一个“单线程化线程池”，也就是只有一个线程的线程池，所创建的线程池用唯一的工作线程来执行任务，使用此方法创建的线程池能保证所有任务按照指定顺序（如FIFO）执行。

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.          public static final int SLEEP_GAP = 500;
  6.           //异步任务的执行目标类
  7.          static class TargetTask implements Runnable
  8.          {
  9.              static AtomicInteger taskNo = new AtomicInteger(1);
  10.              private String taskName;
  11.              public TargetTask()
  12.              {
  13.                  taskName = "task-" + taskNo.get();
  14.                  taskNo.incrementAndGet();
  15.              }
  16.              public void run()
  17.              {
  18.                  Print.tco("任务：" + taskName + " doing");
  19.                  // 线程睡眠一会
  20.                  sleepMilliSeconds(SLEEP_GAP);
  21.                  Print.tco(taskName + " 运行结束.");
  22.              }
  23.          }
  25.          //测试用例：只有一个线程的线程池
  26.          @Test
  27.          public void testSingleThreadExecutor()
  28.          {
  29.              ExecutorService pool = Executors.newSingleThreadExecutor();
  30.              for (int i = 0; i < 5; i++)
  31.              {
  32.                  pool.execute(new TargetTask());
  33.                  pool.submit(new TargetTask());
  34.              }
  35.              sleepSeconds(1000);
  36.              //关闭线程池
  37.              pool.shutdown();
  38.          }
  39.      }
  1. newFixedThreadPool创建“固定数量的线程池” ```java package com.crazymakercircle.multithread.basic.create3; // 省略import public class CreateThreadPoolDemo {
    1.   public static final int SLEEP_GAP = 500;
    2.   //异步任务的执行目标类
    3.   static class TargetTask implements Runnable
    4.   {
    5.   //为了节约篇幅，省略重复内容
    6.   }
    7.  //测试用例：只有3个线程固定大小的线程池
    8.   @Test
    9.   public void testNewFixedThreadPool()
    10.   {
    11.       ExecutorService pool = Executors.newFixedThreadPool(3);
    12.       for (int i = 0; i < 5; i++)
    13.       {
    14.           pool.execute(new TargetTask());
    15.           pool.submit(new TargetTask());
    16.       }
    17.       sleepSeconds(1000);
    18.       //关闭线程池
    19.       pool.shutdown();
    20.   }
    21.   // 省略其他
    }
  2. 3. newCachedThreadPool创建“可缓存线程池”
  4. 该方法用于创建一个“可缓存线程池”，如果线程池内的某些线程无事可干成为空闲线程，“可缓存线程池”可灵活回收这些空闲线程。
  5. ```java
  6. package com.crazymakercircle.multithread.basic.create3;
  7.      // 省略import
  8.      public class CreateThreadPoolDemo
  9.      {
  10.          public static final int SLEEP_GAP = 500;
  11.          //异步任务的执行目标类
  12.          static class TargetTask implements Runnable
  13.          {
  14.          //为了节约篇幅，省略重复内容
  15.          }
  16.             //测试用例：“可缓存线程池”
  17.              @Test
  18.              public void testNewCacheThreadPool()
  19.              {
  20.                  ExecutorService pool = Executors.newCachedThreadPool();
  21.                  for (int i = 0; i < 5; i++)
  22.                  {
  23.                      pool.execute(new TargetTask());
  24.                      pool.submit(new TargetTask());
  25.                  }
  26.                  sleepSeconds(1000);
  27.                  //关闭线程池
  28.                  pool.shutdown();
  29.              }
  30.          // 省略其他
  31.      }
  1. newScheduledThreadPool创建“可调度线程池”

该方法用于创建一个“可调度线程池”，即一个提供“延时”和“周期性”任务调度功能的ScheduledExecutorService类型的线程池。Executors提供了多个创建“可调度线程池”的工厂方法

  1. //方法一：创建一个可调度线程池，池内仅含有一个线程
  2. public static ScheduledExecutorService newSingleThreadScheduledExecutor();
  4. //方法二：创建一个可调度线程池，池内含有N个线程，N的值为输入参数corePoolSize
  5. public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) ;
  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.          public static final int SLEEP_GAP = 500;
  6.          //异步任务的执行目标类
  7.          static class TargetTask implements Runnable
  8.          {
  9.          //为了节约篇幅，省略重复内容
  10.          }
  12.          //测试用例：“可调度线程池”
  13.          @Test
  14.          public void testNewScheduledThreadPool()
  15.          {
  16.               ScheduledExecutorService scheduled = 
  17.                                 Executors.newScheduledThreadPool(2);
  18.               for (int i = 0; i < 2; i++)
  19.              {
  20.                  scheduled.scheduleAtFixedRate(new TargetTask(),
  21.                          0, 500, TimeUnit.MILLISECONDS);
  22.         // 以上参数中：0表示首次执行任务的延迟时间，500表示每次执行任务的间隔时间
  23.                  // TimeUnit.MILLISECONDS是执行的时间间隔数值，单位为毫秒
  24.              }
  25.              sleepSeconds(1000);
  26.              //关闭线程池
  27.              scheduled.shutdown();
  28.          }
  29.      // 省略其他
  30.      }

ScheduleExecutorService中接收被调目标任务的方法之一scheduleAtFixedRate的定义如下：

  1. public ScheduledFuture<?> scheduleAtFixedRate(
  2.              Runnable command,      //异步任务target执行目标实例
  3.              long initialDelay,     //首次执行延时
  4.              long period,           //两次开始执行最小间隔时间
  5.              TimeUnit unit                  //所设置的时间的计时单位，如TimeUnit.SECONDS常量
  6.              );

ScheduleExecutorService中接收被调目标任务的方法之二scheduleWithFixedDelay的定义如下：

  1. public ScheduledFuture<?> scheduleWithFixedDelay(
  2.          Runnable command,  //异步任务target执行目标实例
  3.          long initialDelay,         //首次执行延时
  4.          long delay,          //前一次执行结束到下一次执行开始的间隔时间（间隔执行延迟时间）
  5.          TimeUnit unit        //所设置的时间的计时单位，如TimeUnit.SECONDS常量
  6.      );

1.6.3　线程池的标准创建方式

大部分企业的开发规范都会禁止使用快捷线程池（具体原因稍后介绍），要求通过标准构造器ThreadPoolExecutor去构造工作线程池。Executors工厂类中创建线程池的快捷工厂方法实际上是调用ThreadPoolExecutor（定时任务使用ScheduledThreadPoolExecutor）线程池的构造方法完成的。ThreadPoolExecutor构造方法有多个重载版本，其中一个比较重要的构造器如下：

  1. // 使用标准构造器构造一个普通的线程池
  2.      public ThreadPoolExecutor(
  3.        int corePoolSize,            // 核心线程数，即使线程空闲（Idle），也不会回收
  4.        int maximumPoolSize,                 // 线程数的上限
  5.        long keepAliveTime, 
  6.        TimeUnit unit,   // 线程最大空闲（Idle）时长 
  7.        BlockingQueue<Runnable> workQueue,     // 任务的排队队列
  8.        ThreadFactory threadFactory,
  1. 核心和最大线程数量

参数corePoolSize用于设置核心（Core）线程池数量，参数maximumPoolSize用于设置最大线程数量。线程池执行器将会根据corePoolSize和maximumPoolSize自动维护线程池中的工作线程

  1. BlockingQueue

BlockingQueue（阻塞队列）的实例用于暂时接收到的异步任务，如果线程池的核心线程都在忙，那么所接收到的目标任务缓存在阻塞队列中。

  1. keepAliveTime

线程构造器的keepAliveTime（空闲线程存活时间）参数用于设置池内线程最大Idle（空闲）时长（或者说保活时长），如果超过这个时间，默认情况下Idle、非Core线程会被回收。

1.6.4　向线程池提交任务的两种方式

向线程池提交任务的两种方式大致如下：

  1. 调用execute()方法 ```java //Executor 接口中的方法 void execute(Runnable command);
  2. 2. 调用submit()方法
  3. ```java
  4. //ExecutorService 接口中的方法
  5. <T> Future<T> submit(Callable<T> task); 
  6. <T> Future<T> submit(Runnable task, T result);
  7. Future<?> submit(Runnable task);

以上的submit()和execute()两类方法的区别在哪里呢？大致有以下三点：

  1. Execute()方法只能接收Runnable类型的参数，而submit()方法可以接收Callable、Runnable两种类型的参数。Callable类型的任务是可以返回执行结果的，而Runnable类型的任务不可以返回执行结果。
  2. submit()提交任务后会有返回值，而execute()没有
  3. submit()方便Exception处理

通过submit()返回的Future对象获取结果

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.          // 省略其他
  6.          //测试用例：获取异步调用的结果
  7.          @Test
  8.          public void testSubmit2()
  9.          {
  10.              ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
  11.              Future<Integer> future = pool.submit(new Callable<Integer>()
  12.              {
  13.                  @Override
  14.                  public Integer call() throws Exception
  15.                  {
  16.                      //返回200～300的随机数
  17.                      return RandomUtil.randInRange(200, 300);
  18.                  }
  19.              });
  21.              try
  22.              {
  23.                  Integer result = future.get();
  24.                  Print.tco("异步执行的结果是:" + result);
  25.              } catch (InterruptedException e)
  26.              {
  27.                  Print.tco("异步调用被中断");
  28.                  e.printStackTrace();
  29.              } catch (ExecutionException e)
  30.              {
  31.                  Print.tco("异步调用过程中，发生了异常");
  32.                  e.printStackTrace();
  33.              }
  34.              sleepSeconds(10);
  35.              //关闭线程池
  36.              pool.shutdown();
  37.          }
  38.      }

通过submit()返回的Future对象捕获异常

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.          //异步任务的执行目标类
  6.          static class TargetTask implements Runnable
  7.          {
  8.          //为了节约篇幅，省略重复内容
  9.          }
  11.          //异步的执行目标类：执行过程中将发生异常
  12.          static class TargetTaskWithError extends TargetTask
  13.          {
  14.              public void run()
  15.              {
  16.                  super.run();
  17.                  throw new RuntimeException("Error from " + taskName);
  18.              }
  19.          }
  20.          //测试用例：提交和执行
  21.          @Test
  22.          public void testSubmit()
  23.          {
  24.              ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);

1.6.5　线程池的任务调度流程

image.png
下面是一个错误的线程池配置示例：

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.         @org.junit.Test
  6.          public void testThreadPoolExecutor()
  7.          {
  8.              ThreadPoolExecutor executor = new ThreadPoolExecutor(
  9.                      1, //corePoolSize
  10.                      100, //maximumPoolSize
  11.                      100, //keepAliveTime 空闲保活时长
  12.                      TimeUnit.SECONDS, //空闲保活时长的单位
  13.                      new LinkedBlockingDeque<>(100));//workQueue
  14.              //提交5个任务
  15.              for (int i = 0; i < 5; i++)
  16.              {
  17.                  final int taskIndex = i;
  18.                  executor.execute(() ->
  19.                  {
  20.                      Print.tco("taskIndex = " + taskIndex);
  21.                      try
  22.                      {  //极端测试：无限制睡眠
  23.                          Thread.sleep(Long.MAX_VALUE);
  24.                      } catch (InterruptedException e)
  25.                      {
  26.                          e.printStackTrace();
  27.                      }
  28.                  });
  1. 以上示例创建了最大线程数量maximumPoolSize为100的线程池，仅仅向其中提交了5个任务。理论上，这5个任务都会被执行到，奇怪的是示例中只有1个任务在执行，其他的4个任务都在等待。其他任务被加入到了阻塞队列中，需要等pool-1-thread-1线程执行完第一个任务后，才能依次从阻塞队列取出执行。但是，实例中的第一个任务是一个永远也没有办法完成的任务，所以其他的4个任务只能永远在阻塞队列中等待着。由于参数配置得不合理，因此出现了以上的奇怪现象。
  1. 核心和最大线程数量、BlockingQueue队列等参数如果配置得不合理，可能会造成异步任务得不到预期的并发执行，造成严重的排队等待现象。
  2. 线程池的调度器创建线程的一条重要的规则是：在corePoolSize已满之后，还需要等阻塞队列已满，才会去创建新的线程。

    1.6.6　ThreadFactory（线程工厂）

    ```java package java.util.concurrent; public interface ThreadFactory {
    1.   //唯一的方法：创建一个新线程
    2.   Thread newThread(Runnable target);
    }
  1. 下面的例子首先实现一个简单的线程工厂，然后基于该线程工厂快捷创建线程池，具体的代码如下：
  2. ```java
  3. package com.crazymakercircle.multithread.basic.create3;
  4.      // 省略import
  5.      public class CreateThreadPoolDemo
  6.      {
  7.          //一个简单的线程工厂
  8.          static public class SimpleThreadFactory implements ThreadFactory
  9.          {
  10.              static AtomicInteger threadNo = new AtomicInteger(1);
  11.              //实现其唯一的创建线程方法
  12.              @Override
  13.              public Thread newThread(Runnable target)
  14.              {
  15.                  String threadName = "simpleThread-" + threadNo.get();
  16.                  Print.tco("创建一个线程，名称为：" + threadName);
  17.                  threadNo.incrementAndGet();
  18.                  //设置线程名称和异步执行目标
  19.                  Thread thread = new Thread(target,threadName);
  20.                  //设置为守护线程
  21.                  thread.setDaemon(true);
  22.                  return thread;
  23.              }
  24.          }
  26.          //线程工厂的测试用例
  27.          @org.junit.Test
  28.          public void testThreadFactory()
  29.          {
  30.              //使用自定义线程工厂快捷创建一个固定大小的线程池
  31.              ExecutorService pool =
  32.                      Executors.newFixedThreadPool(2,new  SimpleThreadFactory());
  33.              for (int i = 0; i < 5; i++)
  34.              {
  35.                  pool.submit(new TargetTask());
  36.              }
  37.              //等待10秒
  38.              sleepSeconds(10);
  39.              Print.tco("关闭线程池");
  40.              pool.shutdown();
  41.          }
  42.          // 省略其他
  43.      }

1.6.7　任务阻塞队列

Java中的阻塞队列（BlockingQueue）与普通队列相比有一个重要的特点：在阻塞队列为空时会阻塞当前线程的元素获取操作
Java线程池使用BlockingQueue实例暂时接收到的异步任务，BlockingQueue是JUC包的一个超级接口，比较常用的实现类有：

  1. ArrayBlockingQueue
  2. LinkedBlockingQueue
  3. PriorityBlockingQueue
  4. DelayQueue
  5. SynchronousQueue

    1.6.8　调度器的钩子方法

    ThreadPoolExecutor线程池调度器为每个任务执行前后都提供了钩子方法。 ```java //任务执行之前的钩子方法（前钩子） protected void beforeExecute(Thread t, Runnable r) { } //任务执行之后的钩子方法（后钩子） protected void afterExecute(Runnable r, Throwable t) { } //线程池终止时的钩子方法（停止钩子） protected void terminated() { }
  2. 1. beforeExecute：异步任务执行之前的钩子方法
  3. 1. afterExecute：异步任务执行之后的钩子方法
  4. 1. terminated：线程池终止时的钩子方法
  6. 为线程池定制钩子方法的示例，具体代码如下：
  7. ```java
  8. package com.crazymakercircle.multithread.basic.create3;
  9.      // 省略import
  10.      public class CreateThreadPoolDemo
  11.      {
  12.          @org.junit.Test
  13.          public void testHooks()
  14.          {
  15.              ExecutorService pool = new ThreadPoolExecutor(2, //coreSize
  16.                          4, //最大线程数
  17.                         60,//空闲保活时长
  18.                      TimeUnit.SECONDS, 
  19.                         new LinkedBlockingQueue<>(2)) //等待队列
  20.              {
  21.               //继承：调度器终止钩子
  22.                  @Override
  23.                  protected void terminated() 
  24.                  {
  25.                      Print.tco("调度器已经终止!");
  26.                  }
  28.                 //继承：执行前钩子
  29.                 @Override
  30.                  protected void beforeExecute(Thread t, Runnable target)
  31.                  {
  32.                      Print.tco( target +"前钩被执行");
  33.                      //记录开始执行时间
  34.                      startTime.set(System.currentTimeMillis());
  35.                      super.beforeExecute(t, target);
  36.                  }
  38.                 //继承：执行后钩子
  39.                  @Override
  40.                  protected void afterExecute(Runnable target, Throwable t)
  41.                  {
  42.                      super.afterExecute(target, t);
  43.                      //计算执行时长
  44.                      long time = (System.currentTimeMillis() - startTime.get()) ;
  45.                      Print.tco( target + " 后钩被执行, 任务执行时长（ms）：" + time);
  46.                      //清空本地变量
  47.                      startTime.remove();
  48.                  }
  49.              };
  51.              for (int i = 1; i <= 5; i++)
  52.              {
  53.                  pool.execute(new TargetTask());
  54.              }
  55.              //等待10秒
  56.              sleepSeconds(10);
  57.              Print.tco("关闭线程池");
  58.              pool.shutdown();
  59.          }
  60.          // 省略其他
  61.      }

1.6.9　线程池的拒绝策略

在线程池的任务缓存队列为有界队列（有容量限制的队列）的时候，如果队列满了，提交任务到线程池的时候就会被拒绝。总体来说，任务被拒绝有两种情况：

  1. 线程池已经被关闭
  2. 工作队列已满且maximumPoolSize已满。

无论以上哪种情况任务被拒绝，线程池都会调用RejectedExecutionHandler实例的rejectedExecution方法。RejectedExecutionHandler是拒绝策略的接口,JUC为该接口提供了以下几种实现：

  • AbortPolicy：拒绝策略。
  • DiscardPolicy：抛弃策略。
  • DiscardOldestPolicy：抛弃最老任务策略。
  • CallerRunsPolicy：调用者执行策略。
  • 自定义策略。

image.png

  1. AbortPolicy

使用该策略时，如果线程池队列满了，新任务就会被拒绝，并且抛出RejectedExecutionException异常。该策略是线程池默认的拒绝策略。

  1. DiscardPolicy

该策略是AbortPolicy的Silent（安静）版本，如果线程池队列满了，新任务就会直接被丢掉，并且不会有任何异常抛出。

  1. DiscardOldestPolicy

抛弃最老任务策略，也就是说如果队列满了，就会将最早进入队列的任务抛弃，从队列中腾出空间，再尝试加入队列。因为队列是队尾进队头出，队头元素是最老的，所以每次都是移除队头元素后再尝试入队。

  1. CallerRunsPolicy

调用者执行策略。在新任务被添加到线程池时，如果添加失败，那么提交任务线程会自己去执行该任务，不会使用线程池中的线程去执行新任务。

  1. 自定义策略

如果以上拒绝策略都不符合需求，那么可自定义一个拒绝策略，实现RejectedExecutionHandler接口的rejectedExecution方法即可。

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  5.          //一个简单的线程工厂
  6.          static public class SimpleThreadFactoryimplements ThreadFactory
  7.          {
  8.          //为了节约篇幅，省略重复内容
  9.      }
  11.          //自定义拒绝策略
  12.          public static class CustomIgnorePolicy
  13.                           implements RejectedExecutionHandler
  14.          {
  15.              public void rejectedExecution(Runnable r, ThreadPoolExecutor e)
  16.              {
  17.                  // 可做日志记录等
  18.                  Print.tco(r + " rejected; " +
  19.                           " - getTaskCount: " + e.getTaskCount());
  20.              }
  21.          }
  23.          @org.junit.Test
  24.          public void testCustomIgnorePolicy()
  25.          {
  26.              int corePoolSize = 2;          //核心线程数
  27.              int maximumPoolSize = 4;       //最大线程数
  28.              long keepAliveTime = 10;
  29.              TimeUnit unit = TimeUnit.SECONDS;
  30.              //最大排队任务数
  31.              BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);
  32.              //线程工厂
  33.              ThreadFactory threadFactory = new SimpleThreadFactory();
  34.              //拒绝和异常处理策略
  35.              RejectedExecutionHandler policy = new CustomIgnorePolicy();
  36.              ThreadPoolExecutor pool = new ThreadPoolExecutor(
  37.                      corePoolSize,
  38.                      maximumPoolSize,
  39.                      keepAliveTime, unit,
  40.                      workQueue,
  41.                      threadFactory,
  42.                      policy);
  44.              // 预启动所有核心线程
  45.              pool.prestartAllCoreThreads();
  46.              for (int i = 1; i <= 10; i++)
  47.              {
  48.                  pool.execute(new TargetTask());
  49.              }
  50.              //等待10秒
  51.              sleepSeconds(10);
  52.              Print.tco("关闭线程池");
  53.              pool.shutdown();
  54.          }
  55.          // 省略其他
  56.      }

1.6.10　线程池的优雅关闭

一般情况下，线程池启动后建议手动关闭。在介绍线程池的优雅关闭之前，我们先了解一下线程池的状态。线程池总共存在5种状态，定义在ThreadPoolExecutor类中，具体代码如下：

  1. package java.util.concurrent;
  2.      // 省略import
  3.      public class ThreadPoolExecutor extends AbstractExecutorService {
  4.           // runState is stored in the high-order bits
  5.          private static final int RUNNING   = -1 << COUNT_BITS;
  6.          private static final int SHUTDOWN          =  0 << COUNT_BITS;
  7.          private static final int STOP              =  1 << COUNT_BITS;
  8.          private static final int TIDYING           =  2 << COUNT_BITS;
  9.          private static final int TERMINATED        =  3 << COUNT_BITS;
  10.          // 省略其他
  11.      }
  1. RUNNING：线程池创建之后的初始状态，这种状态下可以执行任务。
  2. SHUTDOWN：该状态下线程池不再接受新任务，但是会将工作队列中的任务执行完毕。
  3. STOP：该状态下线程池不再接受新任务，也不会处理工作队列中的剩余任务，并且将会中断所有工作线程。
  4. TIDYING：该状态下所有任务都已终止或者处理完成，将会执行terminated()钩子方法。
  5. TERMINATED：执行完terminated()钩子方法之后的状态。

线程池的状态转换规则为：

  1. 线程池创建之后状态为RUNNING。
  2. 执行线程池的shutdown()实例方法，会使线程池状态从RUNNING转变为SHUTDOWN。
  3. 执行线程池的shutdownNow()实例方法，会使线程池状态从RUNNING转变为STOP。
  4. 当线程池处于SHUTDOWN状态时，执行其shutdownNow()方法会将其状态转变为STOP。
  5. 等待线程池的所有工作线程停止，工作队列清空之后，线程池状态会从STOP转变为TIDYING。
  6. 执行完terminated()钩子方法之后，线程池状态从TIDYING转变为TERMINATED。

优雅地关闭线程池主要涉及的方法有3个：

  1. shutdown：是JUC提供的一个有序关闭线程池的方法，此方法会等待当前工作队列中的剩余任务全部执行完成之后，才会执行关闭，但是此方法被调用之后线程池的状态转为SHUTDOWN，线程池不会再接收新的任务。

image.png

  1. shutdownNow：是JUC提供的一个立即关闭线程池的方法，此方法会打断正在执行的工作线程，并且会清空当前工作队列中的剩余任务，返回的是尚未执行的任务。
  2. awaitTermination：等待线程池完成关闭。在调用线程池的shutdown()与shutdownNow()方法时，当前线程会立即返回，不会一直等待直到线程池完成关闭。如果需要等到线程池关闭完成，可以调用awaitTermination()方法。
  1. shutdown()方法的原理 ```java public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try {
    1.   // 检查权限
    2.   checkShutdownAccess();
    3.   // 设置线程池状态
    4.   advanceRunState(SHUTDOWN);
    5.   // 中断空闲线程
    6.   interruptIdleWorkers();
    7.   // 钩子函数，主要用于清理一些资源
    8.   onShutdown();
    } finally {
    1.   mainLock.unlock();
    } tryTerminate(); }
  1. Shutdown()方法首先加锁，其次检查调用者是否用于执行线程池关闭的Java Security权限。接着shutdown()方法会将线程池状态变为SHUTDOWN，在这之后线程池不再接受提交的新任务。此时如果还继续往线程池提交任务，将会使用线程池拒绝策略响应，默认的拒绝策略将会使用ThreadPoolExecutor.AbortPolicy，接收新任务时会抛出RejectedExecutionException异常。
  3. 2. shutdownNow()方法的原理
  4. ```java
  5. public List<Runnable> shutdownNow()
  6. {
  7.      List<Runnable> tasks;
  8.      final ReentrantLock mainLock = this.mainLock;
  9.      mainLock.lock();
  10.      try
  11.      {
  12.          // 检查状态
  13.          checkShutdownAccess();
  14.          // 将线程池状态变为 STOP
  15.          advanceRunState(STOP);
  16.          // 中断所有线程，包括工作线程以及空闲线程
  17.          interruptWorkers();
  18.          // 丢弃工作队列中的剩余任务
  19.          tasks = drainQueue();
  20.      } finally
  21.      {
  22.          mainLock.unlock();
  23.      }
  24.      tryTerminate();
  25.      return tasks;
  26. }
  1. shutdownNow()方法将会把线程池状态设置为STOP，然后中断所有线程（包括工作线程以及空闲线程），最后清空工作队列，取出工作队列所有未完成的任务返回给调用者。与有序的shutdown()方法相比，shutdownNow()方法比较粗暴，直接中断工作线程。不过这里需要注意的是，中断线程并不代表线程立刻结束，只是通过工作线程的interrupt()实例方法设置了中断状态，这里需要用户程序主动配合线程进行中断操作。
  1. awaitTermination()方法的使用

调用了线程池的shutdown()与shutdownNow()方法之后，用户程序都不会主动等待线程池关闭完成，如果需要等待线程池关闭完成，需要调用awaitTermination()进行主动等待。调用方法大致如下：

  1. threadPool.shutdown();
  2.  try {
  3.      //一直等待，直到线程池完成关闭
  4.      while (!threadPool.awaitTermination(60,TimeUnit.SECONDS)){
  5.          System.out.println("线程池任务还未执行结束");
  6.      }
  7.  } catch (InterruptedException e) {
  8.      e.printStackTrace();
  9.  }

  1. 优雅地关闭线程池

    1. public static void shutdownThreadPoolGracefully(ExecutorService threadPool) {
    2.      if (!(threadPool instanceof ExecutorService) || threadPool.isTerminated()) {
    3.          return;
    4.      }
    5.      try {
    6.          threadPool.shutdown();   //拒绝接受新任务
    7.      } catch (SecurityException e) {
    8.          return;
    9.      } catch (NullPointerException e) {
    10.          return;
    11.      }
    12.      try {
    13.          // 等待 60 s，等待线程池中的任务完成执行
    14.          if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
    15.              // 调用 shutdownNow 取消正在执行的任务
    16.              threadPool.shutdownNow();
    17.              // 再次等待 60 s，如果还未结束，可以再次尝试，或则直接放弃
    18.              if (!threadPool.awaitTermination(60, TimeUnit.SECONDS)) {
    19.                  System.err.println("线程池任务未正常执行结束");
    20.              }
    21.          }
    22.      } catch (InterruptedException ie) {
    23.          // 捕获异常，重新调用 shutdownNow
    24.          threadPool.shutdownNow();
    25.      }
    26.      //任然没有关闭，循环关闭1000次，每次等待10毫秒
    27.      if (!threadPool.isTerminated()) {
    28.          try {
    29.              for (int i = 0; i < 1000; i++) {
    30.                  if (threadPool.awaitTermination(10, TimeUnit.MILLISECONDS)) {
    31.                      break;
    32.                  }
    33.                  threadPool.shutdownNow();
    34.              }
    35.          } catch (InterruptedException e) {
    36.              System.err.println(e.getMessage());
    37.          } catch (Throwable e) {
    38.              System.err.println(e.getMessage());
    39.          }
    40.      }
    41.  }

  2. 注册JVM钩子函数自动关闭线程池

如果使用了线程池，可以在JVM中注册一个钩子函数，在JVM进程关闭之前，由钩子函数自动将线程池优雅地关闭，以确保资源正常释放。

  1. package com.crazymakercircle.util;
  2.      // 省略import
  3.      public class ThreadUtil
  4.      {
  6.          //懒汉式单例创建线程池：用于执行定时、顺序任务
  7.          static class SeqOrScheduledTargetThreadPoolLazyHolder
  8.          {
  9.              //线程池：用于定时任务、顺序排队执行任务
  10.              static final ScheduledThreadPoolExecutor EXECUTOR =
  11.                              new ScheduledThreadPoolExecutor( 1,
  12.                              new CustomThreadFactory("seq"));
  14.              static
  15.              {
  16.                  //注册JVM关闭时的钩子函数
  17.                  Runtime.getRuntime().addShutdownHook(
  18.                                       new ShutdownHookThread("定时和顺序任务线程池",
  19.                                       new Callable<Void>()
  20.                          {
  21.                              @Override
  22.                              public Void call() throws Exception
  23.                              {
  24.                                  //优雅地关闭线程池
  25.                                  shutdownThreadPoolGracefully(EXECUTOR);
  26.                                  return null;
  27.                              }
  28.                          }));
  29.              }
  30.          }
  31.          // 省略不相干代码
  32.      }

1.6.11　Executors快捷创建线程池的潜在问题

  1. 使用Executors创建“固定数量的线程池”的潜在问题 ```java public static ExecutorService newFixedThreadPool(int nThreads)
    1.   {
    2.       return new ThreadPoolExecutor(
    3.               nThreads,                                              // 核心线程数
    4.               nThreads,                                              // 最大线程数
    5.               0L,                                           // 线程最大空闲（Idle）时长
    6.               TimeUnit.MILLISECONDS,         // 时间单位：毫秒
    7.               new LinkedBlockingQueue<Runnable>()      //任务的排队队列，无界队列
    8.       );
    9.   }
  1.     使用Executors创建“固定数量的线程池”的潜在问题主要存在于其workQueue上，其值为LinkedBlockingQueue（无界阻塞队列）。如果任务提交速度持续大于任务处理速度，就会造成队列中大量的任务等待。如果队列很大，很有可能导致JVM出现OOM（Out Of Memory）异常，即内存资源耗尽。
  3. 2. 使用Executors创建“单线程化线程池”的潜在问题
  4. ```java
  5. public static ExecutorService newSingleThreadExecutor()
  6.          {
  7.              return new FinalizableDelegatedExecutorService
  8.                      (new ThreadPoolExecutor(
  9.                              1,                                                     // 核心线程数
  10.                              1,                                                     // 最大线程数
  11.                              0L,                                                    // 线程最大空闲（Idle）时长
  12.                              TimeUnit.MILLISECONDS,         //时间单位：毫秒
  13.                              new LinkedBlockingQueue<Runnable>()      //无界队列
  14.                      ));
  15.          }

为了演示“单线程化线程池”的corePoolSize始终保持为1而不能被修改，接下来首先调用newSingleThreadExecutor()工厂方法创建一个“单线程化线程池”，然后试图修改其corePoolSize属性，具体的代码如下：

  1. @org.junit.Test
  2.  public void testNewFixedThreadPool2()
  3.  {
  4.      //创建一个固定大小的线程池
  5.      ExecutorService fixedExecutorService = 
  6.                      Executors.newFixedThreadPool(1);
  7.      ThreadPoolExecutor threadPoolExecutor = 
  8.                      (ThreadPoolExecutor) fixedExecutorService;
  9.      Print.tco(threadPoolExecutor.getMaximumPoolSize());
  10.      //设置核心线程数
  11.      threadPoolExecutor.setCorePoolSize(8);
  13.      //创建一个单线程化的线程池
  14.      ExecutorService singleExecutorService = 
  15.                          Executors.newSingleThreadExecutor();
  16.      //转换成普通线程池，会抛出运行时异常 java.lang.ClassCastException
  17.      ((ThreadPoolExecutor) singleExecutorService).setCorePoolSize(8);
  18.  }
  1. 使用Executors创建的“单线程化线程池”与“固定大小的线程池”一样，其潜在问题仍然存在于其workQueue属性上，该属性的值为LinkedBlockingQueue（无界阻塞队列）。如果任务提交速度持续大于任务处理速度，就会造成队列大量阻塞。如果队列很大，很有可能导致JVM的OOM异常，甚至造成内存资源耗尽。
  1. 使用Executors创建“可缓存线程池”的潜在问题 ```java public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(
    1.       0,                                                             // 核心线程数
    2.       Integer.MAX_VALUE,                             // 最大线程数
    3.       60L,                                                 // 线程最大空闲（Idle）时长
    4.       TimeUnit.MILLISECONDS,                         // 时间单位：毫秒
    5.       new SynchronousQueue<Runnable>() // 任务的排队队列，无界队列
    ); }
  1. 4.使用Executors创建“可调度线程池”的潜在问题
  2. <a name="t1W2U"></a>
  3. # 1.7　确定线程池的线程数
  4. <a name="i1hIu"></a>
  5. ## 1.7.1　按照任务类型对线程池进行分类
  7. 1. IO密集型任务
  8. 1. CPU密集型任务
  9. 1. 混合型任务
  10. <a name="i8LmW"></a>
  11. ## 1.7.2　为IO密集型任务确定线程数
  12. 由于IO密集型任务的CPU使用率较低，导致线程空余时间很多，因此通常需要开CPU核心数两倍的线程。当IO线程空闲时，可以启用其他线程继续使用CPU，以提高CPU的使用率。<br />Netty的IO处理任务就是典型的IO密集型任务。所以，Netty的Reactor（反应器）实现类（定制版的线程池）的IO处理线程数默认正好为CPU核数的两倍，以下是其相关的代码：
  13. ```java
  14. //多线程版本Reactor实现类
  15.      public abstract class MultithreadEventLoopGroup extends
  16.              MultithreadEventExecutorGroup implements EventLoopGroup {
  18.          //IO事件处理线程数
  19.          private static final int DEFAULT_EVENT_LOOP_THREADS;
  21.          //IO事件处理线程数默认值为CPU核数的两倍
  22.          static {
  23.              DEFAULT_EVENT_LOOP_THREADS = Math.max(1,
  24.                       SystemPropertyUtil.getInt("io.netty.eventLoopThreads",
  25.                       Runtime.getRuntime().availableProcessors() * 2));
  26.          }
  28.          /**
  29.           *构造器
  30.           */
  31.          protected MultithreadEventLoopGroup(int nThreads, 
  32.                      ThreadFactory threadFactory, Object... args) {
  33.              super(nThreads == 0?
  34.                       DEFAULT_EVENT_LOOP_THREADS : nThreads, threadFactory, args);
  35.          }
  36.        // 省略其他
  37.      }
  1. package com.crazymakercircle.util;
  2.      // 省略import
  3.      public class ThreadUtil
  4.      {
  5.          //CPU核数
  6.          public static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
  7.          //IO处理线程数
  8.          public static final int IO_MAX = Math.max(2, CPU_COUNT * 2);
  9.          /**
  10.           * 空闲保活时限，单位秒
  11.           */
  12.          private static final int KEEP_ALIVE_SECONDS = 30;
  13.          /**
  14.           * 有界队列size
  15.           */
  16.          private static final int QUEUE_SIZE = 128;
  17.          //懒汉式单例创建线程池：用于IO密集型任务
  18.         public class IoIntenseTargetThreadPoolLazyHolder {
  19.     //线程池： 用于IO密集型任务
  20.     public static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(
  21.             IO_MAX,
  22.             IO_MAX,
  23.             KEEP_ALIVE_SECONDS,
  24.             TimeUnit.SECONDS,
  25.             new LinkedBlockingQueue(QUEUE_SIZE),
  26.             new ThreadUtil.CustomThreadFactory("io"));
  28.     public static ThreadPoolExecutor getInnerExecutor() {
  29.         return EXECUTOR;
  30.     }
  32.     static {
  33.         log.info("线程池已经初始化");
  35.         EXECUTOR.allowCoreThreadTimeOut(true);
  36.         //JVM关闭时的钩子函数
  37.         Runtime.getRuntime().addShutdownHook(
  38.                 new ShutdownHookThread("IO密集型任务线程池", new Callable<Void>() {
  39.                     @Override
  40.                     public Void call() throws Exception {
  41.                         //优雅关闭线程池
  42.                         shutdownThreadPoolGracefully(EXECUTOR);
  43.                         return null;
  44.                     }
  45.                 }));
  46.     }
  47. }

1.7.3　为CPU密集型任务确定线程数

CPU密集型任务并行执行的数量应当等于CPU的核心数。

  1. package com.crazymakercircle.util;
  2.      // 省略import
  3.      public class ThreadUtil
  4.      {
  5.          //CPU核数
  6.          private static final int CPU_COUNT =
  7.                                          Runtime.getRuntime().availableProcessors();
  9.          private static final int MAXIMUM_POOL_SIZE = CPU_COUNT;
  11.          //懒汉式单例创建线程池：用于CPU密集型任务
  12.          private static class CpuIntenseTargetThreadPoolLazyHolder
  13.          {
  14.              //线程池：用于CPU密集型任务
  15.              private static final ThreadPoolExecutor EXECUTOR = 
  16.                                                                new ThreadPoolExecutor(
  17.                      MAXIMUM_POOL_SIZE,
  18.                      MAXIMUM_POOL_SIZE,
  19.                      KEEP_ALIVE_SECONDS,
  20.                      TimeUnit.SECONDS,
  21.                      new LinkedBlockingQueue(QUEUE_SIZE),
  22.                      new CustomThreadFactory("cpu"));
  24.              static
  25.              {
  26.                  EXECUTOR.allowCoreThreadTimeOut(true);
  27.                  //JVM关闭时的钩子函数
  28.                  Runtime.getRuntime().addShutdownHook(
  29.                          new ShutdownHookThread("CPU密集型任务线程池",
  30.                                                                    new Callable<Void>()
  31.                          {
  32.                              @Override
  33.                              public Void call() throws Exception
  34.                              {
  35.                                  //优雅地关闭线程池
  36.                                  shutdownThreadPoolGracefully(EXECUTOR);
  37.                                  return null;
  38.                              }
  39.                          }));
  40.              }
  41.          }
  42.          // 省略不相干代码
  43.      }

1.7.4　为混合型任务确定线程数

最佳线程数 = ((线程等待时间+线程CPU时间) / 线程CPU时间) * CPU核数
通过公式可以看出：等待时间所占的比例越高，需要的线程就越多；CPU耗时所占的比例越高，需要的线程就越少。

  1. package com.crazymakercircle.util;
  2.      // 省略import
  3.      public class ThreadUtil
  4.      {
  5.          private static final int MIXED_MAX = 128;  //最大线程数
  6.          private static final String MIXED_THREAD_AMOUNT = "mixed.thread.amount";
  8.          //懒汉式单例创建线程池：用于混合型任务
  9.          private static class MixedTargetThreadPoolLazyHolder
  10.          {
  11.              //首先从环境变量 mixed.thread.amount 中获取预先配置的线程数
  12.              //如果没有对 mixed.thread.amount进行配置，就使用常量 MIXED_MAX作为线程数
  13.              private static final int max = 
  14.                                (null != System.getProperty(MIXED_THREAD_AMOUNT)) ?
  15.                      Integer.parseInt(System.getProperty(MIXED_THREAD_AMOUNT))

在使用如上代码创建混合型线程池时，建议按照前面的最佳线程数估算公式提前预估好线程数（如80），然后设置在环境变量mixed.thread.amount中，测试用例如下：

  1. package com.crazymakercircle.multithread.basic.create3;
  2.      // 省略import
  3.      public class CreateThreadPoolDemo
  4.      {
  6.          @org.junit.Test
  7.          public void testMixedThreadPool()
  8.          {
  9.              System.getProperties().put("mixed.thread", 600);
  10.              // 获取自定义的混合线程池
  11.              ExecutorService pool =
  12.                      ThreadUtil.getMixedTargetThreadPool();
  13.              for (int i = 0; i < 1000; i++)
  14.              {
  15.                  try
  16.                  {
  17.                      sleepMilliSeconds(10);
  18.                      pool.submit(new TargetTask());
  20.                  } catch (RejectedExecutionException e)
  21.                  {
  22.                    //异常处理
  23.                  }
  24.              }
  25.              //等待10s
  26.              sleepSeconds(10);
  27.              Print.tco("关闭线程池");
  28.          }
  29.          // 省略其他
  30.      }

1.8　ThreadLocal原理与实战

在Java的多线程并发执行过程中，为了保证多个线程对变量的安全访问，可以将变量放到ThreadLocal类型的对象中，使变量在每个线程中都有独立值，不会出现一个线程读取变量时被另一个线程修改的现象。ThreadLocal类通常被翻译为“线程本地变量”类或者“线程局部变量”类。

1.8.1　ThreadLocal的基本使用

image.png
下面的例子通过ThreadLocal的成员方法进行“线程本地变量”中线程本地值的设置、获取和移除，具体的代码如下：

  1. package com.crazymakercircle.multithread.basic.threadlocal;
  2.      // 省略import
  3.      public class ThreadLocalTest
  4.      {
  5.          @Data
  6.          static class Foo
  7.          {
  8.              //实例总数
  9.              static final AtomicInteger AMOUNT = new AtomicInteger(0);
  10.              //对象的编号
  11.              int index = 0;
  12.              //对象的内容
  13.              int bar = 10;
  14.              //构造器
  15.              public Foo()
  16.              {
  17.                  index = AMOUNT.incrementAndGet(); //总数增加，并且给对象编号
  18.              }
  19.              @Override
  20.              public String toString()
  21.              {
  22.                  return index + "@Foo{bar=" + bar + '}';
  23.              }
  24.          }
  26.          //定义线程本地变量
  27.          private static final ThreadLocal<Foo> LOCAL_FOO =  new ThreadLocal<Foo>();
  29.          public static void main(String[] args) throws InterruptedException
  30.          {
  31.               //获取自定义的混合型线程池
  32.              ThreadPoolExecutor threadPool = 
  33.                                      ThreadUtil.getMixedTargetThreadPool();
  35.              //提交5个任务，将会用到5个线程
  36.              for (int i = 0; i < 5; i++)
  37.              {
  38.                  threadPool.execute(new Runnable()
  39.                  {
  40.                      @Override
  41.                      public void run()
  42.                      {
  43.                          //获取“线程本地变量”中当前线程所绑定的值
  44.                          if (LOCAL_FOO.get() == null)
  45.                          {
  46.               //设置“线程本地变量”中当前线程所绑定的值
  47.                              LOCAL_FOO.set(new Foo());
  48.                          }
  49.                          Print.tco("初始的本地值：" + LOCAL_FOO.get());
  50.                          //每个线程执行10次
  51.                          for (int i = 0; i < 10; i++)
  52.                          {
  53.                              Foo foo = LOCAL_FOO.get();
  54.                              foo.setBar(foo.getBar() + 1);  //值增1
  55.                              sleepMilliSeconds(10);
  56.                          }
  57.                          Print.tco("累加10次之后的本地值：" + LOCAL_FOO.get());
  59.                          //删除“线程本地变量”中当前线程所绑定的值
  60.                          LOCAL_FOO.remove(); //这点对于线程池中的线程尤其重要
  61.                      }
  62.                  });
  63.              }
  64.          }
  65.      }
  1. 在当前线程尚未绑定值时，如果希望从线程本地变量获取到初始值，而且不想采用以上的“判空后设值”这种相对烦琐的方式，可以调用ThreadLocal.withInitial(…)静态工厂方法，在定义ThreadLocal对象时设置一个获取初始值的回调函数，具体的代码如下：
  1. ThreadLocal<Foo> LOCAL_FOO = ThreadLocal.withInitial(() -> new Foo());

以上代码并没有使用new ThreadLocal()构造一个ThreadLocal对象，而是调用withInitial(…)工厂方法创建一个ThreadLocal对象，并传递了一个获取初始值的Lambda回调函数。在线程尚未绑定值而直接从“线程本地变量”获取值时，将会取得回调函数被调用之后所返回的值。

1.8.2　ThreadLocal的使用场景

  1. 线程隔离

  2. 跨函数传递数据

    1.8.3　使用ThreadLocal进行线程隔离

    下面的代码来自Hibernate，代码中通过ThreadLocal进行数据库连接（Session）的“线程本地化”存储，主要的代码如下： ```java private static final ThreadLocal threadSession = new ThreadLocal();

    public static Session getSession() throws InfrastructureException { 

    1.   Session s = (Session) threadSession.get();
    2.   try {
    3.       if (s == null) {
    4.           s = getSessionFactory().openSession();
    5.           threadSession.set(s);
    6.       }  
    7.   } catch (HibernateException ex) {
    8.       throw new InfrastructureException(ex);
    9.   }  
    10.   return s;

    }

  1. <a name="GpaZW"></a>
  2. ## 1.8.4　使用ThreadLocal进行跨函数数据传递
  3. ```java
  4. package com.crazymaker.springcloud.common.context;
  5.      // 省略import
  6.      public class SessionHolder
  7.      {
  8.          // session id，线程本地变量
  9.          private static final ThreadLocal<String> sidLocal =
  10.                                                new ThreadLocal<>("sidLocal");
  12.          // 用户信息，线程本地变量
  13.          private static final ThreadLocal<UserDTO> sessionUserLocal =
  14.                                                 new ThreadLocal<>("sessionUserLocal");
  16.          // session，线程本地变量
  17.          private static final ThreadLocal<HttpSession> sessionLocal = 
  18.                                                    new ThreadLocal<>("sessionLocal");
  19.      // 省略其他  
  21.          /**
  22.           *保存session在线程本地变量中
  23.            */
  24.          public static void setSession(HttpSession session)
  25.          {
  26.              sessionLocal.set(session);
  27.          }
  29.          /**
  30.           * 取得绑定在线程本地变量中的session 
  31.            */
  32.          public static HttpSession getSession()
  33.          {
  34.              HttpSession session = sessionLocal.get();
  35.              Assert.notNull(session, "session未设置");
  36.              return session;
  37.          }
  38.          // 省略其他  
  39.      }

1.8.5　ThreadLocal内部结构演进

1.8.6　ThreadLocal源码分析

  1. set(T value)方法 ```java public void set(T value) {

    1.       //获取当前线程对象
    2.       Thread t = Thread.currentThread();
    4.       //获取当前线程的ThreadLocalMap 成员
    5.       ThreadLocalMap map = getMap(t);
    7.       //判断map是否存在
    8.       if (map != null)
    9.       { 
    10.           //value被绑定到threadLocal实例
    11.           map.set(this, value);
    12.       }
    13.       else
    14.       {
    15.           // 如果当前线程没有ThreadLocalMap成员实例
    16.           // 创建一个ThreadLocalMap实例，然后作为成员关联到t（thread实例）
    17.           createMap(t, value);
    18.       }
    19.   }
    21.   // 获取线程t的ThreadLocalMap成员
    22.   ThreadLocalMap getMap(Thread t) {
    23.       return t.threadLocals;
    24.   }
    26.   // 线程t创建一个ThreadLocalMap成员
    27.   // 并为新的Map成员设置第一个“Key-Value对”，Key为当前的ThreadLocal实例
    28.   void createMap(Thread t, T firstValue) {
    29.       t.threadLocals = new ThreadLocalMap(this, firstValue);
    30.   }
  2. 2. get()方法
  3. ```java
  4. public T get() {
  5.          // 获得当前线程对象
  6.          Thread t = Thread.currentThread();
  7.          // 获得线程对象的ThreadLocalMap 内部成员
  8.          ThreadLocalMap map = getMap(t);
  10.         // 如果当前线程的内部map成员存在
  11.         if (map != null) {
  12.              // 以当前ThreadLocal为Key，尝试获得条目
  13.              ThreadLocalMap.Entry e = map.getEntry(this);
  14.             // 条目存在
  15.              if (e != null) {
  16.                  T result = (T)e.value;
  17.                  return result;
  18.              }
  19.          }
  20.          // 如果当前线程对应的map不存在
  21.          // 或者map存在，但是当前ThreadLocal实例没有对应的“Key-Value对”，返回初始值
  22.          return setInitialValue();
  23.      }
  25.      // 设置ThreadLocal关联的初始值并返回
  26.      private T setInitialValue() {
  27.          // 调用初始化钩子函数，获取初始值
  28.          T value = initialValue();
  29.          Thread t = Thread.currentThread();
  30.          ThreadLocalMap map = getMap(t);
  31.          if (map != null)
  32.              map.set(this, value);
  33.          else
  34.              createMap(t, value);
  35.          return value;
  36.      }
  1. remove()方法 ```java public void remove() {
    1.        ThreadLocalMap m = getMap(Thread.currentThread());
    2.        if (m != null)
    3.            m.remove(this);
    4.    }
  2. 4. initialValue()方法
  3. ```java
  4. protected T initialValue() {
  5.              return null;
  6.          }

使用工厂方法构造ThreadLocal实例的代码如下：

  1. ThreadLocal<Foo> LOCAL_FOO = ThreadLocal.withInitial(() -> new Foo());

JDK定义的ThreadLocal.withInitial(…)静态工厂方法及其内部子类SuppliedThreadLocal的源码如下：

  1. //ThreadLocal工厂方法可以设置本地变量初始值钩子函数
  2.          public static <S> ThreadLocal<S> withInitial(
  3.                                      Supplier<? extends S> supplier) {
  4.              return new SuppliedThreadLocal<>(supplier);
  5.          }
  7.          //内部静态子类
  8.          //继承了ThreadLocal，重写了initialValue()方法，返回钩子函数的值作为初始值
  9.          static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
  10.              //保存钩子函数
  11.              private final Supplier<? extends T> supplier;
  12.              //传入钩子函数
  13.              SuppliedThreadLocal(Supplier<? extends T> supplier) {
  14.                  this.supplier = Objects.requireNonNull(supplier);
  15.              }
  17.              @Override
  18.              protected T initialValue() {
  19.                  return supplier.get();  //返回钩子函数的值作为初始值
  20.              }
  21.          }

1.8.7　ThreadLocalMap源码分析

  1. ThreadLocalMap的主要成员变量 ```java public class ThreadLocal {
    1.   // 省略其他
    static class ThreadLocalMap { 
    1.       // Map的条目数组，作为哈希表使用
    2.       private Entry[] table;
    3.       // Map的条目初始容量16
    4.       private static final int INITIAL_CAPACITY = 16;
    5.       // Map的条目数量 
    6.       private int size = 0;
    7.       // 扩容因子
    8.       private int threshold; 
    9.       // Map的条目类型，一个静态的内部类
    10.       // Entry 继承子WeakReference, Key为ThreadLocal实例
    11.       static class Entry extends WeakReference<ThreadLocal<?>> {
    12.           Object value; //条目的值
    13.           Entry(ThreadLocal<?> k, Object v) {
    14.               super(k);
    15.               value = v;
    16.           }
    17.       }
    18.   // 省略其他
    }
  2. 2. Entry的Key需要使用弱引用
  3. ```java
  4. // Entry 继承了WeakReference，并使用WeakReference对Key进行包装
  5.      static class Entry extends WeakReference<ThreadLocal<?>> {
  6.          Object value; //值
  7.          Entry(ThreadLocal<?> k, Object v) {
  8.              super(k);  //使用WeakReference对Key进行包装
  9.              value = v;
  10.          }
  11.      }
  1. 什么是弱引用呢？仅有弱引用（Weak Reference）指向的对象只能生存到下一次垃圾回收之前。换句话说，当GC发生时，无论内存够不够，仅有弱引用所指向的对象都会被回收。而拥有强引用指向的对象则不会被直接回收。

  1. 编程规范推荐使用static final修饰ThreadLocal对象

    1.8.8　ThreadLocal综合使用案例

  2. 尽量使用private static final修饰ThreadLocal实例。使用private与final修饰符主要是为了尽可能不让他人修改、变更ThreadLocal变量的引用，使用static修饰符主要是为了确保ThreadLocal实例的全局唯一。

  3. ThreadLocal使用完成之后务必调用remove()方法。这是简单、有效地避免ThreadLocal引发内存泄漏问题的方法。 ```java package com.crazymakercircle.multithread.basic.threadlocal; // 省略import public class ThreadLocalTest2 {

    1.   /**
    2.    * 模拟业务方法
    3.    */
    4.   public void serviceMethod()
    5.   {
    6.       //睡眠500毫秒，模拟执行所需的时间（耗时）
    7.       sleepMilliSeconds(500);
    9.       //记录从开始调用到当前这个点（ "point-1"）的耗时
    10.       SpeedLog.logPoint("point-1 service");
    12.       //调用DAO()方法：模拟DAO业务方法
    13.       daoMethod();
    15.       //调用RPC()方法：模拟RPC远程业务方法
    16.       rpcMethod();
    17.   }
    19.   /**
    20.    * 模拟DAO业务方法
    21.    */
    22.   public void daoMethod()
    23.   {
    24.       //睡眠400毫秒，模拟执行所需的时间
    25.       sleepMilliSeconds(400);
    27.       //记录上一个点（"point-1"）到这里（"point-2"）的耗时
    28.       SpeedLog.logPoint("point-2 dao");
    29.   }
    31.   /**
    32.    * 模拟RPC远程业务方法
    33.    */
    34.   public void rpcMethod()
    35.   {
    36.       //睡眠400毫秒，模拟执行所需的时间
    37.       sleepMilliSeconds(600);
    39.       //记录上一个点（"point-2"）到这里（"point-3"）的耗时
    40.       SpeedLog.logPoint("point-3 rpc");
    41.   }
    42.   // 省略不相干代码

    }

  1. SpeedLog类的代码大致如下：
  2. ```java
  3. package com.crazymakercircle.multithread.basic.threadlocal;
  4.      // 省略import
  5.      public class SpeedLog
  6.      {
  7.          /**
  8.           * 记录调用耗时的本地Map变量
  9.           */
  10.      private static final ThreadLocal<Map<String, Long>>
  11.       TIME_RECORD_LOCAL =ThreadLocal.withInitial(SpeedLog::initialStartTime);
  13.          /**
  14.           * 记录调用耗时的本地Map变量的初始化方法
  15.           */
  16.          public static Map<String, Long> initialStartTime()
  17.          {
  18.              Map<String, Long> map = new HashMap<>();
  19.              map.put("start", System.currentTimeMillis());
  20.              map.put("last", System.currentTimeMillis());
  21.              return map;
  22.          }
  24.          /**
  25.           * 开始耗时记录
  26.           */
  27.          public static final void beginSpeedLog()
  28.          {
  29.              Print.fo("开始耗时记录");
  30.              TIME_RECORD_LOCAL.get();
  31.          }
  33.          /**
  34.           * 结束耗时记录
  35.           */
  36.          public static final void endSpeedLog()
  37.          {
  38.              TIME_RECORD_LOCAL.remove();
  39.              Print.fo("结束耗时记录");
  40.          }
  42.          /**
  43.           * 耗时埋点
  44.           */
  45.          public static final void logPoint(String point)
  46.          {
  47.              //获取上一次的时间
  48.              Long last = TIME_RECORD_LOCAL.get().get("last");
  49.              //计算上一次埋点到当前埋点的耗时
  50.              Long cost = System.currentTimeMillis() - last;
  52.              //保存上一次埋点到当前埋点的耗时
  53.              TIME_RECORD_LOCAL.get().put(point + " cost:", cost);
  55.               //保存当前时间，供下一次埋点使用
  56.              TIME_RECORD_LOCAL.get().put("last", System.currentTimeMillis());
  57.          }
  58.          // 省略不相干代码
  59.      }