注意：本章节会涉及到 操作系统 相关知识。

在了解多线程之前，让我们回顾一下操作系统中提到的进程概念：

Java多线程 - 图1

进程是程序执行的实体，每一个进程都是一个应用程序（比如我们运行QQ、浏览器、LOL、网易云音乐等软件），都有自己的内存空间，CPU一个核心同时只能处理一件事情，当出现多个进程需要同时运行时，CPU一般通过时间片轮转调度算法，来实现多个进程的同时运行。

image.png

在早期的计算机中，进程是拥有资源和独立运行的最小单位，也是程序执行的最小单位。但是，如果我希望两个任务同时进行，就必须运行两个进程，由于每个进程都有一个自己的内存空间，进程之间的通信就变得非常麻烦（比如要共享某些数据）而且执行不同进程会产生上下文切换，非常耗时，那么能否实现在一个进程中就能够执行多个任务呢？

image.png

后来，线程横空出世，一个进程可以有多个线程，线程是程序执行中一个单一的顺序控制流程，现在线程才是程序执行流的最小单元，各个线程之间共享程序的内存空间（也就是所在进程的内存空间），上下文切换速度也高于进程。

在Java中，我们从开始，一直以来编写的都是单线程应用程序（运行main()方法的内容），也就是说只能同时执行一个任务（无论你是调用方法、还是进行计算，始终都是依次进行的，也就是同步的），而如果我们希望同时执行多个任务（两个方法同时在运行或者是两个计算同时在进行，也就是异步的），就需要用到Java多线程框架。实际上一个Java程序启动后，会创建很多线程，不仅仅只运行一个主线程：

  1. public static void main(String[] args) {
  2.     ThreadMXBean bean = ManagementFactory.getThreadMXBean();
  3.     long[] ids = bean.getAllThreadIds();
  4.     ThreadInfo[] infos = bean.getThreadInfo(ids);
  5.     for (ThreadInfo info : infos) {
  6.         System.out.println(info.getThreadName());
  7.     }
  8. }

关于除了main线程默认以外的线程，涉及到JVM相关底层原理，在这里不做讲解，了解就行。

线程的创建和启动

通过创建Thread对象来创建一个新的线程，Thread构造方法中需要传入一个Runnable接口的实现（其实就是编写要在另一个线程执行的内容逻辑）同时Runnable只有一个未实现方法，因此可以直接使用lambda表达式：

  1. @FunctionalInterface
  2. public interface Runnable {
  3.     /**
  4.      * When an object implementing interface <code>Runnable</code> is used
  5.      * to create a thread, starting the thread causes the object's
  6.      * <code>run</code> method to be called in that separately executing
  7.      * thread.
  8.      * <p>
  9.      * The general contract of the method <code>run</code> is that it may
  10.      * take any action whatsoever.
  11.      *
  12.      * @see     java.lang.Thread#run()
  13.      */
  14.     public abstract void run();
  15. }

创建好后，通过调用start()方法来运行此线程：

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {    //直接编写逻辑
  3.         System.out.println("我是另一个线程！");
  4.     });
  5.     t.start();   //调用此方法来开始执行此线程
  6. }

可能上面的例子看起来和普通的单线程没两样，那我们先来看看下面这段代码的运行结果：

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         System.out.println("我是线程："+Thread.currentThread().getName());
  4.         System.out.println("我正在计算 0-10000 之间所有数的和...");
  5.         int sum = 0;
  6.         for (int i = 0; i <= 10000; i++) {
  7.             sum += i;
  8.         }
  9.         System.out.println("结果："+sum);
  10.     });
  11.     t.start();
  12.     System.out.println("我是主线程！");
  13. }

我们发现，这段代码执行输出结果并不是按照从上往下的顺序了，因为他们分别位于两个线程，他们是同时进行的！如果你还是觉得很疑惑，我们接着来看下面的代码运行结果：

  1. public static void main(String[] args) {
  2.     Thread t1 = new Thread(() -> {
  3.         for (int i = 0; i < 50; i++) {
  4.             System.out.println("我是一号线程："+i);
  5.         }
  6.     });
  7.     Thread t2 = new Thread(() -> {
  8.         for (int i = 0; i < 50; i++) {
  9.             System.out.println("我是二号线程："+i);
  10.         }
  11.     });
  12.     t1.start();
  13.     t2.start();
  14. }

我们可以看到打印实际上是在交替进行的，也证明了他们是在同时运行！

注意：我们发现还有一个run方法，也能执行线程里面定义的内容，但是run是直接在当前线程执行，并不是创建一个线程执行！

image.png

实际上，线程和进程差不多，也会等待获取CPU资源，一旦获取到，就开始按顺序执行我们给定的程序，当需要等待外部IO操作（比如Scanner获取输入的文本），就会暂时处于休眠状态，等待通知，或是调用sleep()方法来让当前线程休眠一段时间：

  1. public static void main(String[] args) throws InterruptedException {
  2.     System.out.println("l");
  3.     Thread.sleep(1000);    //休眠时间，以毫秒为单位，1000ms = 1s
  4.     System.out.println("b");
  5.     Thread.sleep(1000);
  6.     System.out.println("w");
  7.     Thread.sleep(1000);
  8.     System.out.println("nb!");
  9. }

我们也可以使用stop()方法来强行终止此线程：

  1. public static void main(String[] args) throws InterruptedException {
  2.     Thread t = new Thread(() -> {
  3.         Thread me = Thread.currentThread();   //获取当前线程对象
  4.         for (int i = 0; i < 50; i++) {
  5.             System.out.println("打印:"+i);
  6.             if(i == 20) me.stop();  //此方法会直接终止此线程
  7.         }
  8.     });
  9.     t.start();
  10. }

虽然stop()方法能够终止此线程，但是并不是所推荐的做法，有关线程中断相关问题，我们会在后面继续了解。

思考：猜猜以下程序输出结果：

  1. private static int value = 0;
  3. public static void main(String[] args) throws InterruptedException {
  4.     Thread t1 = new Thread(() -> {
  5.         for (int i = 0; i < 10000; i++) value++;
  6.         System.out.println("线程1完成");
  7.     });
  8.     Thread t2 = new Thread(() -> {
  9.         for (int i = 0; i < 10000; i++) value++;
  10.         System.out.println("线程2完成");
  11.     });
  12.     t1.start();
  13.     t2.start();
  14.     Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
  15.     System.out.println(value);
  16. }

我们发现，value最后的值并不是我们理想的结果，有关为什么会出现这种问题，在我们学习到线程锁的时候，再来探讨。

线程的休眠和中断

我们前面提到，一个线程处于运行状态下，线程的下一个状态会出现以下情况：

  • 当CPU给予的运行时间结束时，会从运行状态回到就绪（可运行）状态，等待下一次获得CPU资源。
  • 当线程进入休眠 / 阻塞(如等待IO请求) / 手动调用wait()方法时，会使得线程处于等待状态，当等待状态结束后会回到就绪状态。
  • 当线程出现异常或错误 / 被stop() 方法强行停止 / 所有代码执行结束时，会使得线程的运行终止。

而这个部分我们着重了解一下线程的休眠和中断，首先我们来了解一下如何使得线程进如休眠状态：

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         try {
  4.             System.out.println("l");
  5.             Thread.sleep(1000);   //sleep方法是Thread的静态方法，它只作用于当前线程（它知道当前线程是哪个）
  6.             System.out.println("b");    //调用sleep后，线程会直接进入到等待状态，直到时间结束
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.     });
  11.     t.start();
  12. }

通过调用sleep()方法来将当前线程进入休眠，使得线程处于等待状态一段时间。我们发现，此方法显示声明了会抛出一个InterruptedException异常，那么这个异常在什么时候会发生呢？

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         try {
  4.             Thread.sleep(10000);  //休眠10秒
  5.         } catch (InterruptedException e) {
  6.             e.printStackTrace();
  7.         }
  8.     });
  9.     t.start();
  10.     try {
  11.         Thread.sleep(3000);   //休眠3秒，一定比线程t先醒来
  12.         t.interrupt();   //调用t的interrupt方法
  13.     } catch (InterruptedException e) {
  14.         e.printStackTrace();
  15.     }
  16. }

我们发现，每一个Thread对象中，都有一个interrupt()方法，调用此方法后，会给指定线程添加一个中断标记以告知线程需要立即停止运行或是进行其他操作，由线程来响应此中断并进行相应的处理，我们前面提到的stop()方法是强制终止线程，这样的做法虽然简单粗暴，但是很有可能导致资源不能完全释放，而类似这样的发送通知来告知线程需要中断，让线程自行处理后续，会更加合理一些，也是更加推荐的做法。我们来看看interrupt的用法：

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         System.out.println("线程开始运行！");
  4.         while (true){   //无限循环
  5.             if(Thread.currentThread().isInterrupted()){   //判断是否存在中断标志
  6.                 break;   //响应中断
  7.             }
  8.         }
  9.         System.out.println("线程被中断了！");
  10.     });
  11.     t.start();
  12.     try {
  13.         Thread.sleep(3000);   //休眠3秒，一定比线程t先醒来
  14.         t.interrupt();   //调用t的interrupt方法
  15.     } catch (InterruptedException e) {
  16.         e.printStackTrace();
  17.     }
  18. }

通过isInterrupted()可以判断线程是否存在中断标志，如果存在，说明外部希望当前线程立即停止，也有可能是给当前线程发送一个其他的信号，如果我们并不是希望收到中断信号就是结束程序，而是通知程序做其他事情，我们可以在收到中断信号后，复位中断标记，然后继续做我们的事情：

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         System.out.println("线程开始运行！");
  4.         while (true){
  5.             if(Thread.currentThread().isInterrupted()){   //判断是否存在中断标志
  6.                 System.out.println("发现中断信号，复位，继续运行...");
  7.                 Thread.interrupted();  //复位中断标记（返回值是当前是否有中断标记，这里不用管）
  8.             }
  9.         }
  10.     });
  11.     t.start();
  12.     try {
  13.         Thread.sleep(3000);   //休眠3秒，一定比线程t先醒来
  14.         t.interrupt();   //调用t的interrupt方法
  15.     } catch (InterruptedException e) {
  16.         e.printStackTrace();
  17.     }
  18. }

复位中断标记后，会立即清除中断标记。那么，如果现在我们想暂停线程呢？我们希望线程暂时停下，比如等待其他线程执行完成后，再继续运行，那这样的操作怎么实现呢？

  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         System.out.println("线程开始运行！");
  4.         Thread.currentThread().suspend();   //暂停此线程
  5.         System.out.println("线程继续运行！");
  6.     });
  7.     t.start();
  8.     try {
  9.         Thread.sleep(3000);   //休眠3秒，一定比线程t先醒来
  10.         t.resume();   //恢复此线程
  11.     } catch (InterruptedException e) {
  12.         e.printStackTrace();
  13.     }
  14. }

虽然这样很方便地控制了线程的暂停状态，但是这两个方法我们发现实际上也是不推荐的做法，它很容易导致死锁！有关为什么被弃用的原因，我们会在线程锁继续探讨。

线程的优先级

实际上，Java程序中的每个线程并不是平均分配CPU时间的，为了使得线程资源分配更加合理，Java采用的是抢占式调度方式，优先级越高的线程，优先使用CPU资源！我们希望CPU花费更多的时间去处理更重要的任务，而不太重要的任务，则可以先让出一部分资源。线程的优先级一般分为以下三种：

  • MIN_PRIORITY 最低优先级
  • MAX_PRIORITY 最高优先级
  • NOM_PRIORITY 常规优先级
  1. public static void main(String[] args) {
  2.     Thread t = new Thread(() -> {
  3.         System.out.println("线程开始运行！");
  4.     });
  5.     t.start();
  6.     t.setPriority(Thread.MIN_PRIORITY);  //通过使用setPriority方法来设定优先级
  7. }

优先级越高的线程，获得CPU资源的概率会越大，并不是说一定优先级越高的线程越先执行！

线程的礼让和加入

我们还可以在当前线程的工作不重要时，将CPU资源让位给其他线程，通过使用yield()方法来将当前资源让位给其他同优先级线程：

  1. public static void main(String[] args) {
  2.     Thread t1 = new Thread(() -> {
  3.         System.out.println("线程1开始运行！");
  4.         for (int i = 0; i < 50; i++) {
  5.             if(i % 5 == 0) {
  6.                 System.out.println("让位！");
  7.                 Thread.yield();
  8.             }
  9.             System.out.println("1打印："+i);
  10.         }
  11.         System.out.println("线程1结束！");
  12.     });
  13.     Thread t2 = new Thread(() -> {
  14.         System.out.println("线程2开始运行！");
  15.         for (int i = 0; i < 50; i++) {
  16.             System.out.println("2打印："+i);
  17.         }
  18.     });
  19.     t1.start();
  20.     t2.start();
  21. }

观察结果，我们发现，在让位之后，尽可能多的在执行线程2的内容。

当我们希望一个线程等待另一个线程执行完成后再继续进行，我们可以使用join()方法来实现线程的加入：

  1. public static void main(String[] args) {
  2.     Thread t1 = new Thread(() -> {
  3.         System.out.println("线程1开始运行！");
  4.         for (int i = 0; i < 50; i++) {
  5.             System.out.println("1打印："+i);
  6.         }
  7.         System.out.println("线程1结束！");
  8.     });
  9.     Thread t2 = new Thread(() -> {
  10.         System.out.println("线程2开始运行！");
  11.         for (int i = 0; i < 50; i++) {
  12.             System.out.println("2打印："+i);
  13.             if(i == 10){
  14.                 try {
  15.                     System.out.println("线程1加入到此线程！");
  16.                     t1.join();    //在i==10时，让线程1加入，先完成线程1的内容，在继续当前内容
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         }
  22.     });
  23.     t1.start();
  24.     t2.start();
  25. }

我们发现，线程1加入后，线程2等待线程1待执行的内容全部执行完成之后，再继续执行的线程2内容。注意，线程的加入只是等待另一个线程的完成，并不是将另一个线程和当前线程合并！我们来看看：

  1. public static void main(String[] args) {
  2.     Thread t1 = new Thread(() -> {
  3.         System.out.println(Thread.currentThread().getName()+"开始运行！");
  4.         for (int i = 0; i < 50; i++) {
  5.             System.out.println(Thread.currentThread().getName()+"打印："+i);
  6.         }
  7.         System.out.println("线程1结束！");
  8.     });
  9.     Thread t2 = new Thread(() -> {
  10.         System.out.println("线程2开始运行！");
  11.         for (int i = 0; i < 50; i++) {
  12.             System.out.println("2打印："+i);
  13.             if(i == 10){
  14.                 try {
  15.                     System.out.println("线程1加入到此线程！");
  16.                     t1.join();    //在i==10时，让线程1加入，先完成线程1的内容，在继续当前内容
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         }
  22.     });
  23.     t1.start();
  24.     t2.start();
  25. }

实际上，t2线程只是暂时处于等待状态，当t1执行结束时，t2才开始继续执行，只是在效果上看起来好像是两个线程合并为一个线程在执行而已。

线程锁和线程同步

在开始讲解线程同步之前，我们需要先了解一下多线程情况下Java的内存管理：

image.png

线程之间的共享变量（比如之前悬念中的value变量）存储在主内存（main memory）中，每个线程都有一个私有的工作内存（本地内存），工作内存中存储了该线程以读/写共享变量的副本。它类似于我们在计算机组成原理中学习的多处理器高速缓存机制：

Java多线程 - 图6

高速缓存通过保存内存中数据的副本来提供更加快速的数据访问，但是如果多个处理器的运算任务都涉及同一块内存区域，就可能导致各自的高速缓存数据不一致，在写回主内存时就会发生冲突，这就是引入高速缓存引发的新问题，称之为：缓存一致性。

实际上，Java的内存模型也是这样类似设计的，当我们同时去操作一个共享变量时，如果仅仅是读取还好，但是如果同时写入内容，就会出现问题！好比说一个银行，如果我和我的朋友同时在银行取我账户里面的钱，难道取1000还可能吐2000出来吗？我们需要一种更加安全的机制来维持秩序，保证数据的安全性！

悬念破案

我们再来回顾一下之前留给大家的悬念：

  1. private static int value = 0;
  3. public static void main(String[] args) throws InterruptedException {
  4.     Thread t1 = new Thread(() -> {
  5.         for (int i = 0; i < 10000; i++) value++;
  6.         System.out.println("线程1完成");
  7.     });
  8.     Thread t2 = new Thread(() -> {
  9.         for (int i = 0; i < 10000; i++) value++;
  10.         System.out.println("线程2完成");
  11.     });
  12.     t1.start();
  13.     t2.start();
  14.     Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
  15.     System.out.println(value);
  16. }

实际上，当两个线程同时读取value的时候，可能会同时拿到同样的值，而进行自增操作之后，也是同样的值，再写回主内存后，本来应该进行2次自增操作，实际上只执行了一次！

image.png

那么要去解决这样的问题，我们就必须采取某种同步机制，来限制不同线程对于共享变量的访问！我们希望的是保证共享变量value自增操作的原子性（原子性是指一个操作或多个操作要么全部执行，且执行的过程不会被任何因素打断，包括其他线程，要么就都不执行）

线程锁

通过synchronized关键字来创造一个线程锁，首先我们来认识一下synchronized代码块，它需要在括号中填入一个内容，必须是一个对象或是一个类，我们在value自增操作外套上同步代码块：

  1. private static int value = 0;
  3. public static void main(String[] args) throws InterruptedException {
  4.     Thread t1 = new Thread(() -> {
  5.         for (int i = 0; i < 10000; i++) {
  6.             synchronized (Main.class){
  7.                 value++;
  8.             }
  9.         }
  10.         System.out.println("线程1完成");
  11.     });
  12.     Thread t2 = new Thread(() -> {
  13.         for (int i = 0; i < 10000; i++) {
  14.             synchronized (Main.class){
  15.                 value++;
  16.             }
  17.         }
  18.         System.out.println("线程2完成");
  19.     });
  20.     t1.start();
  21.     t2.start();
  22.     Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
  23.     System.out.println(value);
  24. }

我们发现，现在得到的结果就是我们想要的内容了，因为在同步代码块执行过程中，拿到了我们传入对象或类的锁（传入的如果是对象，就是对象锁，不同的对象代表不同的对象锁，如果是类，就是类锁，类锁只有一个，实际上类锁也是对象锁，是Class类实例，但是Class类实例同样的类无论怎么获取都是同一个），但是注意两个线程必须使用同一把锁！

当一个线程进入到同步代码块时，会获取到当前的锁，而这时如果其他使用同样的锁的同步代码块也想执行内容，就必须等待当前同步代码块的内容执行完毕，在执行完毕后会自动释放这把锁，而其他的线程才能拿到这把锁并开始执行同步代码块里面的内容。（实际上synchronized是一种悲观锁，随时都认为有其他线程在对数据进行修改，后面有机会我们还会讲到乐观锁，如CAS算法）

那么我们来看看，如果使用的是不同对象的锁，那么还能顺利进行吗？

  1. private static int value = 0;
  3. public static void main(String[] args) throws InterruptedException {
  4.     Main main1 = new Main();
  5.     Main main2 = new Main();
  6.     Thread t1 = new Thread(() -> {
  7.         for (int i = 0; i < 10000; i++) {
  8.             synchronized (main1){
  9.                 value++;
  10.             }
  11.         }
  12.         System.out.println("线程1完成");
  13.     });
  14.     Thread t2 = new Thread(() -> {
  15.         for (int i = 0; i < 10000; i++) {
  16.             synchronized (main2){
  17.                 value++;
  18.             }
  19.         }
  20.         System.out.println("线程2完成");
  21.     });
  22.     t1.start();
  23.     t2.start();
  24.     Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
  25.     System.out.println(value);
  26. }

当对象不同时，获取到的是不同的锁，因此并不能保证自增操作的原子性，最后也得不到我们想要的结果。

synchronized关键字也可以作用于方法上，调用此方法时也会获取锁：

  1. private static int value = 0;
  3. private static synchronized void add(){
  4.     value++;
  5. }
  7. public static void main(String[] args) throws InterruptedException {
  8.     Thread t1 = new Thread(() -> {
  9.         for (int i = 0; i < 10000; i++) add();
  10.         System.out.println("线程1完成");
  11.     });
  12.     Thread t2 = new Thread(() -> {
  13.         for (int i = 0; i < 10000; i++) add();
  14.         System.out.println("线程2完成");
  15.     });
  16.     t1.start();
  17.     t2.start();
  18.     Thread.sleep(1000);  //主线程停止1秒，保证两个线程执行完成
  19.     System.out.println(value);
  20. }

我们发现实际上效果是相同的，只不过这个锁不用你去给，如果是静态方法，就是使用的类锁，而如果是普通成员方法，就是使用的对象锁。通过灵活的使用synchronized就能很好地解决我们之前提到的问题了！

死锁

其实死锁的概念在操作系统中也有提及，它是指两个线程相互持有对方需要的锁，但是又迟迟不释放，导致程序卡住：

image.png

我们发现，线程A和线程B都需要对方的锁，但是又被对方牢牢把握，由于线程被无限期地阻塞，因此程序不可能正常终止。我们来看看以下这段代码会得到什么结果：

  1. public static void main(String[] args) throws InterruptedException {
  2.     Object o1 = new Object();
  3.     Object o2 = new Object();
  4.     Thread t1 = new Thread(() -> {
  5.         synchronized (o1){
  6.             try {
  7.                 Thread.sleep(1000);
  8.                 synchronized (o2){
  9.                     System.out.println("线程1");
  10.                 }
  11.             } catch (InterruptedException e) {
  12.                 e.printStackTrace();
  13.             }
  14.         }
  15.     });
  16.     Thread t2 = new Thread(() -> {
  17.         synchronized (o2){
  18.             try {
  19.                 Thread.sleep(1000);
  20.                 synchronized (o1){
  21.                     System.out.println("线程2");
  22.                 }
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.         }
  27.     });
  28.     t1.start();
  29.     t2.start();
  30. }

那么我们如何去检测死锁呢？我们可以利用jstack命令来检测死锁，首先利用jps找到我们的java进程：

  1. nagocoler@NagodeMacBook-Pro ~ % jps
  2. 51592 Launcher
  3. 51690 Jps
  4. 14955 
  5. 51693 Main
  6. nagocoler@NagodeMacBook-Pro ~ % jstack 51693
  7. ...
  8. Java stack information for the threads listed above:
  9. ===================================================
  10. "Thread-1":
  11.     at com.test.Main.lambda$main$1(Main.java:46)
  12.     - waiting to lock <0x000000076ad27fc0> (a java.lang.Object)
  13.     - locked <0x000000076ad27fd0> (a java.lang.Object)
  14.     at com.test.Main$$Lambda$2/1867750575.run(Unknown Source)
  15.     at java.lang.Thread.run(Thread.java:748)
  16. "Thread-0":
  17.     at com.test.Main.lambda$main$0(Main.java:34)
  18.     - waiting to lock <0x000000076ad27fd0> (a java.lang.Object)
  19.     - locked <0x000000076ad27fc0> (a java.lang.Object)
  20.     at com.test.Main$$Lambda$1/396873410.run(Unknown Source)
  21.     at java.lang.Thread.run(Thread.java:748)
  23. Found 1 deadlock.

jstack自动帮助我们找到了一个死锁，并打印出了相关线程的栈追踪信息。

不推荐使用 suspend()去挂起线程的原因，是因为suspend()在使线程暂停的同时，并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后，被挂起的线程才能继续，从而其它被阻塞在这个锁的线程才可以继续执行。但是，如果resume()操作出现在suspend()之前执行，那么线程将一直处于挂起状态，同时一直占用锁，这就产生了死锁。

wait和notify方法

其实我们之前可能就发现了，Object类还有三个方法我们从来没有使用过，分别是wait()、notify()以及notifyAll()，他们其实是需要配合synchronized来使用的，只有在同步代码块中才能使用这些方法，我们来看看他们的作用是什么：

  1. public static void main(String[] args) throws InterruptedException {
  2.     Object o1 = new Object();
  3.     Thread t1 = new Thread(() -> {
  4.         synchronized (o1){
  5.             try {
  6.                 System.out.println("开始等待");
  7.                 o1.wait();     //进入等待状态并释放锁
  8.                 System.out.println("等待结束！");
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.         }
  13.     });
  14.     Thread t2 = new Thread(() -> {
  15.         synchronized (o1){
  16.             System.out.println("开始唤醒！");
  17.             o1.notify();     //唤醒处于等待状态的线程
  18.               for (int i = 0; i < 50; i++) {
  19.                    System.out.println(i);   
  20.             }
  21.               //唤醒后依然需要等待这里的锁释放之前等待的线程才能继续
  22.         }
  23.     });
  24.     t1.start();
  25.     Thread.sleep(1000);
  26.     t2.start();
  27. }

我们可以发现，对象的wait()方法会暂时使得此线程进入等待状态，同时会释放当前代码块持有的锁，这时其他线程可以获取到此对象的锁，当其他线程调用对象的notify()方法后，会唤醒刚才变成等待状态的线程（这时并没有立即释放锁）。注意，必须是在持有锁（同步代码块内部）的情况下使用，否则会抛出异常！

notifyAll其实和notify一样，也是用于唤醒，但是前者是唤醒所有调用wait()后处于等待的线程，而后者是看运气随机选择一个。

ThreadLocal的使用

既然每个线程都有一个自己的工作内存，那么能否只在自己的工作内存中创建变量仅供线程自己使用呢？

Java多线程 - 图9

我们可以是ThreadLocal类，来创建工作内存中的变量，它将我们的变量值存储在内部（只能存储一个变量），不同的变量访问到ThreadLocal对象时，都只能获取到自己线程所属的变量。

  1. public static void main(String[] args) throws InterruptedException {
  2.     ThreadLocal<String> local = new ThreadLocal<>();  //注意这是一个泛型类，存储类型为我们要存放的变量类型
  3.     Thread t1 = new Thread(() -> {
  4.         local.set("lbwnb");   //将变量的值给予ThreadLocal
  5.         System.out.println("变量值已设定！");
  6.         System.out.println(local.get());   //尝试获取ThreadLocal中存放的变量
  7.     });
  8.     Thread t2 = new Thread(() -> {
  9.         System.out.println(local.get());   //尝试获取ThreadLocal中存放的变量
  10.     });
  11.     t1.start();
  12.     Thread.sleep(3000);    //间隔三秒
  13.     t2.start();
  14. }

上面的例子中，我们开启两个线程分别去访问ThreadLocal对象，我们发现，第一个线程存放的内容，第一个线程可以获取，但是第二个线程无法获取，我们再来看看第一个线程存入后，第二个线程也存放，是否会覆盖第一个线程存放的内容：

  1. public static void main(String[] args) throws InterruptedException {
  2.     ThreadLocal<String> local = new ThreadLocal<>();  //注意这是一个泛型类，存储类型为我们要存放的变量类型
  3.     Thread t1 = new Thread(() -> {
  4.         local.set("lbwnb");   //将变量的值给予ThreadLocal
  5.         System.out.println("线程1变量值已设定！");
  6.         try {
  7.             Thread.sleep(2000);    //间隔2秒
  8.         } catch (InterruptedException e) {
  9.             e.printStackTrace();
  10.         }
  11.         System.out.println("线程1读取变量值：");
  12.         System.out.println(local.get());   //尝试获取ThreadLocal中存放的变量
  13.     });
  14.     Thread t2 = new Thread(() -> {
  15.         local.set("yyds");   //将变量的值给予ThreadLocal
  16.         System.out.println("线程2变量值已设定！");
  17.     });
  18.     t1.start();
  19.     Thread.sleep(1000);    //间隔1秒
  20.     t2.start();
  21. }

我们发现，即使线程2重新设定了值，也没有影响到线程1存放的值，所以说，不同线程向ThreadLocal存放数据，只会存放在线程自己的工作空间中，而不会直接存放到主内存中，因此各个线程直接存放的内容互不干扰。

我们发现在线程中创建的子线程，无法获得父线程工作内存中的变量：

  1. public static void main(String[] args) {
  2.     ThreadLocal<String> local = new ThreadLocal<>();
  3.     Thread t = new Thread(() -> {
  4.        local.set("lbwnb");
  5.         new Thread(() -> {
  6.             System.out.println(local.get());
  7.         }).start();
  8.     });
  9.     t.start();
  10. }

我们可以使用InheritableThreadLocal来解决：

  1. public static void main(String[] args) {
  2.     ThreadLocal<String> local = new InheritableThreadLocal<>();
  3.     Thread t = new Thread(() -> {
  4.        local.set("lbwnb");
  5.         new Thread(() -> {
  6.             System.out.println(local.get());
  7.         }).start();
  8.     });
  9.     t.start();
  10. }

在InheritableThreadLocal存放的内容，会自动向子线程传递。

定时器

我们有时候会有这样的需求，我希望定时执行任务，比如3秒后执行，其实我们可以通过使用Thread.sleep()来实现：

  1. public static void main(String[] args) {
  2.     new TimerTask(() -> System.out.println("我是定时任务！"), 3000).start();   //创建并启动此定时任务
  3. }
  5. static class TimerTask{
  6.     Runnable task;
  7.     long time;
  9.     public TimerTask(Runnable runnable, long time){
  10.         this.task = runnable;
  11.         this.time = time;
  12.     }
  14.     public void start(){
  15.         new Thread(() -> {
  16.             try {
  17.                 Thread.sleep(time);
  18.                 task.run();   //休眠后再运行
  19.             } catch (InterruptedException e) {
  20.                 e.printStackTrace();
  21.             }
  22.         }).start();
  23.     }
  24. }

我们通过自行封装一个TimerTask类，并在启动时，先休眠3秒钟，再执行我们传入的内容。那么现在我们希望，能否循环执行一个任务呢？比如我希望每隔1秒钟执行一次代码，这样该怎么做呢？

  1. public static void main(String[] args) {
  2.     new TimerLoopTask(() -> System.out.println("我是定时任务！"), 3000).start();   //创建并启动此定时任务
  3. }
  5. static class TimerLoopTask{
  6.     Runnable task;
  7.     long loopTime;
  9.     public TimerLoopTask(Runnable runnable, long loopTime){
  10.         this.task = runnable;
  11.         this.loopTime = loopTime;
  12.     }
  14.     public void start(){
  15.         new Thread(() -> {
  16.             try {
  17.                 while (true){   //无限循环执行
  18.                     Thread.sleep(loopTime);
  19.                     task.run();   //休眠后再运行
  20.                 }
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  24.         }).start();
  25.     }
  26. }

现在我们将单次执行放入到一个无限循环中，这样就能一直执行了，并且按照我们的间隔时间进行。

但是终究是我们自己实现，可能很多方面还没考虑到，Java也为我们提供了一套自己的框架用于处理定时任务：

  1. public static void main(String[] args) {
  2.     Timer timer = new Timer();    //创建定时器对象
  3.     timer.schedule(new TimerTask() {   //注意这个是一个抽象类，不是接口，无法使用lambda表达式简化，只能使用匿名内部类
  4.         @Override
  5.         public void run() {
  6.             System.out.println(Thread.currentThread().getName());    //打印当前线程名称
  7.         }
  8.     }, 1000);    //执行一个延时任务
  9. }

我们可以通过创建一个Timer类来让它进行定时任务调度，我们可以通过此对象来创建任意类型的定时任务，包延时任务、循环定时任务等。我们发现，虽然任务执行完成了，但是我们的程序并没有停止，这是因为Timer内存维护了一个任务队列和一个工作线程：

  1. public class Timer {
  2.     /**
  3.      * The timer task queue.  This data structure is shared with the timer
  4.      * thread.  The timer produces tasks, via its various schedule calls,
  5.      * and the timer thread consumes, executing timer tasks as appropriate,
  6.      * and removing them from the queue when they're obsolete.
  7.      */
  8.     private final TaskQueue queue = new TaskQueue();
  10.     /**
  11.      * The timer thread.
  12.      */
  13.     private final TimerThread thread = new TimerThread(queue);
  15.         ...
  16. }

TimerThread继承自Thread，是一个新创建的线程，在构造时自动启动：

  1. public Timer(String name) {
  2.     thread.setName(name);
  3.     thread.start();
  4. }

而它的run方法会循环地读取队列中是否还有任务，如果有任务依次执行，没有的话就暂时处于休眠状态：

  1. public void run() {
  2.     try {
  3.         mainLoop();
  4.     } finally {
  5.         // Someone killed this Thread, behave as if Timer cancelled
  6.         synchronized(queue) {
  7.             newTasksMayBeScheduled = false;
  8.             queue.clear();  // Eliminate obsolete references
  9.         }
  10.     }
  11. }
  13. /**
  14.  * The main timer loop.  (See class comment.)
  15.  */
  16. private void mainLoop() {
  17.   try {
  18.        TimerTask task;
  19.        boolean taskFired;
  20.        synchronized(queue) {
  21.              // Wait for queue to become non-empty
  22.           while (queue.isEmpty() && newTasksMayBeScheduled)   //当队列为空同时没有被关闭时，会调用wait()方法暂时处于等待状态，当有新的任务时，会被唤醒。
  23.                 queue.wait();
  24.           if (queue.isEmpty())
  25.              break;    //当被唤醒后都没有任务时，就会结束循环，也就是结束工作线程
  26.                       ...
  27. }

newTasksMayBeScheduled实际上就是标记当前定时器是否关闭，当它为false时，表示已经不会再有新的任务到来，也就是关闭，我们可以通过调用cancel()方法来关闭它的工作线程：

  1. public void cancel() {
  2.     synchronized(queue) {
  3.         thread.newTasksMayBeScheduled = false;
  4.         queue.clear();
  5.         queue.notify();  //唤醒wait使得工作线程结束
  6.     }
  7. }

因此，我们可以在使用完成后，调用Timer的cancel()方法以正常退出我们的程序：

  1. public static void main(String[] args) {
  2.     Timer timer = new Timer();
  3.     timer.schedule(new TimerTask() {
  4.         @Override
  5.         public void run() {
  6.             System.out.println(Thread.currentThread().getName());
  7.             timer.cancel();  //结束
  8.         }
  9.     }, 1000);
  10. }

守护线程

不要把守护进程和守护线程相提并论！守护进程在后台运行运行，不需要和用户交互，本质和普通进程类似。而守护线程就不一样了，当其他所有的非守护线程结束之后，守护线程是自动结束，也就是说，Java中所有的线程都执行完毕后，守护线程自动结束，因此守护线程不适合进行IO操作，只适合打打杂：

  1. public static void main(String[] args) throws InterruptedException{
  2.     Thread t = new Thread(() -> {
  3.         while (true){
  4.             try {
  5.                 System.out.println("程序正常运行中...");
  6.                 Thread.sleep(1000);
  7.             } catch (InterruptedException e) {
  8.                 e.printStackTrace();
  9.             }
  10.         }
  11.     });
  12.     t.setDaemon(true);   //设置为守护线程（必须在开始之前，中途是不允许转换的）
  13.     t.start();
  14.     for (int i = 0; i < 5; i++) {
  15.         Thread.sleep(1000);
  16.     }
  17. }

在守护线程中产生的新线程也是守护的：

  1. public static void main(String[] args) throws InterruptedException{
  2.     Thread t = new Thread(() -> {
  3.         Thread it = new Thread(() -> {
  4.             while (true){
  5.                 try {
  6.                     System.out.println("程序正常运行中...");
  7.                     Thread.sleep(1000);
  8.                 } catch (InterruptedException e) {
  9.                     e.printStackTrace();
  10.                 }
  11.             }
  12.         });
  13.         it.start();
  14.     });
  15.     t.setDaemon(true);   //设置为守护线程（必须在开始之前，中途是不允许转换的）
  16.     t.start();
  17.     for (int i = 0; i < 5; i++) {
  18.         Thread.sleep(1000);
  19.     }
  20. }

再谈集合类并行方法

其实我们之前在讲解集合类的根接口时，就发现有这样一个方法：

  1. default Stream<E> parallelStream() {
  2.     return StreamSupport.stream(spliterator(), true);
  3. }

并行流，其实就是一个多线程执行的流，它通过默认的ForkJoinPool实现（这里不讲解原理），它可以提高你的多线程任务的速度。

  1. public static void main(String[] args) {
  2.     List<Integer> list = new ArrayList<>(Arrays.asList(1, 4, 5, 2, 9, 3, 6, 0));
  3.     list
  4.             .parallelStream()    //获得并行流
  5.             .forEach(i -> System.out.println(Thread.currentThread().getName()+" -> "+i));
  6. }

我们发现，forEach操作的顺序，并不是我们实际List中的顺序，同时每次打印也是不同的线程在执行！我们可以通过调用forEachOrdered()方法来使用单线程维持原本的顺序：

  1. public static void main(String[] args) {
  2.     List<Integer> list = new ArrayList<>(Arrays.asList(1, 4, 5, 2, 9, 3, 6, 0));
  3.     list
  4.             .parallelStream()    //获得并行流
  5.             .forEachOrdered(System.out::println);
  6. }

我们之前还发现，在Arrays数组工具类中，也包含大量的并行方法：

  1. public static void main(String[] args) {
  2.     int[] arr = new int[]{1, 4, 5, 2, 9, 3, 6, 0};
  3.     Arrays.parallelSort(arr);   //使用多线程进行并行排序，效率更高
  4.     System.out.println(Arrays.toString(arr));
  5. }

更多地使用并行方法，可以更加充分地发挥现代计算机多核心的优势，但是同时需要注意多线程产生的异步问题！

  1. public static void main(String[] args) {
  2.     int[] arr = new int[]{1, 4, 5, 2, 9, 3, 6, 0};
  3.     Arrays.parallelSetAll(arr, i -> {
  4.         System.out.println(Thread.currentThread().getName());
  5.         return arr[i];
  6.     });
  7.     System.out.println(Arrays.toString(arr));
  8. }

通过对Java多线程的了解，我们就具备了利用多线程解决问题的思维！

Java多线程编程实战

这是整个教程最后一个编程实战内容了，下一章节为反射一般开发者使用比较少，属于选学内容，不编排编程实战课程。

生产者与消费者

所谓的生产者消费者模型，是通过一个容器来解决生产者和消费者的强耦合问题。通俗的讲，就是生产者在不断的生产，消费者也在不断的消费，可是消费者消费的产品是生产者生产的，这就必然存在一个中间容器，我们可以把这个容器想象成是一个货架，当货架空的时候，生产者要生产产品，此时消费者在等待生产者往货架上生产产品，而当货架有货物的时候，消费者可以从货架上拿走商品，生产者此时等待货架出现空位，进而补货，这样不断的循环。

通过多线程编程，来模拟一个餐厅的2个厨师和3个顾客，假设厨师炒出一个菜的时间为3秒，顾客吃掉菜品的时间为4秒。

  1. public class Main {
  2.     private static final List<Object> list = new ArrayList<>();
  4.     public static void main(String[] args) {
  5.         Thread c1 = new Thread(Main::add);
  6.         c1.setName("厨师1");
  7.         Thread c2 = new Thread(Main::add);
  8.         c2.setName("厨师2");
  10.         c1.start();
  11.         c2.start();
  14.         Thread s1 = new Thread(Main::eat);
  15.         s1.setName("顾客1");
  16.         Thread s2 = new Thread(Main::eat);
  17.         s2.setName("顾客2");
  18.         Thread s3 = new Thread(Main::eat);
  19.         s3.setName("顾客3");
  21.         s1.start();
  22.         s2.start();
  23.         s3.start();
  25.     }
  28.     private static void add() {
  29.         while (true) {
  30.             try {
  31.                 Thread.sleep(3000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.             synchronized (list) {
  36.                 list.add(new Object());
  37.                 System.out.println(new Date() + Thread.currentThread().getName() + "添加了新菜! ");
  38.                 list.notify(); // 随机唤醒一个
  39.             }
  40.         }
  41.     }
  43.     private static void eat() {
  44.         while (true) {
  45.                 try {
  46.                     synchronized (list) {
  47.                         while (list.isEmpty()) list.wait();
  48.                         System.out.println(new Date() + Thread.currentThread().getName() + "拿走了了菜!======= ");
  49.                         list.remove(0);
  50.                     }
  51.                     Thread.sleep(4000);
  52.                 } catch (InterruptedException e) {
  53.                     e.printStackTrace();
  54.                 }
  55.         }
  56.     }
  57. }