一、线程相关概念

1.1 程序

程序是为了完成特定任务，用某种语言编写的一组指令的集合。
简单来说，就是我们写的代码

1.2 进程

  1. 进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们打开另一个程序，比如运行迅雷，就启动了另一个进程，操作系统也会为迅雷分配新的内存空间
  2. 进程是程序的一次执行过程，或者理解为正在运行的一个程序。是一个动态的过程：即有创建、存在和消亡的状态和过程。

1.3 线程

  1. 线程是由进程创建的，是进程的一个实体
  2. 一个进程可以拥有多个线程

1.4 其他相关概念

  1. 单线程：同一个时刻，只允许执行一个线程
  2. 多线程，同一个时刻，允许多个线程并发执行。比如：一个QQ进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件
  3. 并发：同一个极短时间段内，多个任务交替执行，感觉就像在同一时刻同时执行，一般来说，单核CPU实现的多任务就是并发。
  4. 并行：同一时刻，多个任务同时执行。多核CPU可以实现并行，可以并发和并行同时工作

二、线程基本使用

2.1 创建线程的两种方式

  1. 继承 Thread类，重写 run 方法
  2. 实现 Runnable 接口，重写 run 方法

2.2 线程应用案例1 - 继承 Thread 类

  1. 请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”
  2. 对上题改进：当输出80次 “喵喵，我是小猫咪”，结束该线程
  3. 使用 JConsole 监控线程执行情况，并画出程序示意图 ```java package com.hspedu.thread.threaduse;

/**

  • @author HarborGao
  • @version 1.0

  • 演示通过继承 Thread 类创建线程 */ public class Thread01 { public static void main(String[] args) {

    1.  //创建 Cat对象，可以当作线程使用
    2.  Cat cat = new Cat();
    4.  //源码解读
    5.  /*
    6.  (1) public synchronized void start() {
    7.      ...
    8.      start0();
    9.      ...
    10.      }
    11.  (2) start0() 是本地方法，是JVM调用，底层是 C/C++实现
    12.      真正实现多线程的效果，是start0()，而不是 run
    13.      private native void start0();
    14.  */
    16.  cat.start();  //启动线程
    18.  //cat.run();  //run方法就是一个普通的方法，并没有真正的启动一个线程，main会执行完这句之后再执行后面的语句，相当于还在main线程
    19.  //说明：当 main线程启动一个子线程 Thread-0,主线程不会阻塞，会继续执行
    20.  //这时，主线程和子线程是交替执行的
    22.  System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字 main
    23.  for(int i = 0; i < 60; i++) {
    24.      System.out.println("主线程 i=" + i);
    25.      //让主线程休眠
    26.         Thread.sleep(1000);
    27.  }

    } }

//说明 //1. 当一个类继承了 Thread类，该类就可以当作线程使用 //2. 我们会重写 run方法，写上自己的业务代码 //3. run Thread类，实现了Runnable 接口的 run方法 / @Override public void run() { if (target != null) { target.run(); } } / class Cat extends Thread { int times = 0;

  1. @Override
  2. public void run() {  //重写 run方法，写上自己的业务逻辑
  3.     while (true) {
  4.         //该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”
  5.         System.out.println("喵喵，我是小猫咪" + (++times));
  6.         //让该线程休眠1秒钟   ctrl + alt + t 抓取Exception
  7.         try {
  8.             Thread.sleep(1000);
  9.         } catch (InterruptedException e) {
  10.             e.printStackTrace();
  11.         }
  12.         if (times == 20) {
  13.             break;  //当times到20，就退出循环，这时线程也就退出了
  14.         }
  15.     }
  16. }

}

  1. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1632876641541-dc492a31-9aec-4378-b2c4-f272e63f0c7a.png#clientId=u084f09f2-cf7c-4&from=paste&height=264&id=uc67d1d62&margin=%5Bobject%20Object%5D&name=image.png&originHeight=372&originWidth=846&originalType=binary&ratio=1&size=376805&status=done&style=none&taskId=u6540294f-d7ca-4853-9955-1eedae5b7b3&width=600)<br />![](https://cdn.nlark.com/yuque/0/2021/jpeg/12677686/1632873641073-3c61106b-8be2-450a-befa-e5d3af5c4bac.jpeg)<br />说明：
  3.    1. main线程可以启动多个子线程
  4.    1. 子线程也可以启动子线程
  5.    1. 即使main线程退出了，只要还有子线程在工作，进程依旧存在
  7. **使用 JConsole 监控线程**<br />( 1 ) Run 我们编写的程序<br />    ![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1632873817175-273fdd6d-760c-4527-b59a-96ddc273a403.png#clientId=u084f09f2-cf7c-4&from=paste&height=42&id=ub84f9cea&margin=%5Bobject%20Object%5D&name=image.png&originHeight=42&originWidth=335&originalType=binary&ratio=1&size=2978&status=done&style=none&taskId=ufbf5cdd4-3145-406a-bcb5-4959e3b7f7d&width=335)<br />( 2 ) 控制台选择 Terminal，键入 jconsole 并回车<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1632873910418-28723795-0915-4600-a769-8cde4fb4b495.png#clientId=u084f09f2-cf7c-4&from=paste&height=371&id=uc08f5871&margin=%5Bobject%20Object%5D&name=image.png&originHeight=442&originWidth=714&originalType=binary&ratio=1&size=38655&status=done&style=none&taskId=u17b0918b-f3d6-4d26-ac7c-7d5873e0329&width=600)<br />( 3 ) 选择本地连接，选中运行的代码文件，点击连接，点击不安全的连接<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1632874097946-9dc75031-4010-4479-8926-2c62097ae288.png#clientId=u084f09f2-cf7c-4&from=paste&height=500&id=u28d89f66&margin=%5Bobject%20Object%5D&name=image.png&originHeight=750&originWidth=900&originalType=binary&ratio=1&size=60296&status=done&style=none&taskId=uf8e5a734-c470-4d7a-a772-537210c0267&width=600)<br />注意：如果本地进程列表为空，说明JConsole本地文件夹读写权限不够，解决方案：
  9.    1. 先定位到这个文件夹下 C:\Users\%USER%\AppData\Local\Temp       <br />%USER%是你的系统登录用户名，一般为 Administrator，下同
  10.    1. 找到 hsperfdata_%USER% 目录，右键属性 -> 安全
  11.    1. 点击 编辑 然后给相关用户添加完全控制的权限，应用，确定
  13. ( 4 ) 选择线程，就可以进行监控了<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1632875021850-c65a7a47-0f43-47ea-9efc-2c1bbe6111e6.png#clientId=u084f09f2-cf7c-4&from=paste&height=500&id=u1c8293f7&margin=%5Bobject%20Object%5D&name=image.png&originHeight=750&originWidth=900&originalType=binary&ratio=1&size=71223&status=done&style=none&taskId=ud2e01a55-f16d-48d0-bb2e-853bb8bad37&width=600)
  15. <a name="aamKh"></a>
  16. #### 2.3  线程应用案例2 - 实现 Runnable 接口
  18. 1. Java是单继承的，在某些情况下一个类可能已经继承了一个父类，这时在用继承Thread类的方法来创建线程显然不可能了
  19. 1. Java设计者们提供了另外一个方式创建线程，就是通过实现 Runnable 接口来创建线程
  21. 快速上手 - 案例
  23. 编写程序，该程序每隔一秒，在控制台输出 “hi~”，当输出10次后，自动退出，请使用 Runnable接口的方式实现。
  24. ```java
  25. package com.hspedu.thread_.threaduse_;
  27. /**
  28.  * @author HarborGao
  29.  * @version 1.0
  30.  * 通过实现接口 Runnable 来开发线程
  31.  */
  32. public class Runnable01 {
  33.     public static void main(String[] args) {
  34.         Dog dog = new Dog();
  35.         //注意：这里不能使用 dog.start(); 的方式启动线程
  36.         //创建 Thread 对象，把 dog 对象(实现 Runnable),放入 Thread
  37.         Thread thread = new Thread(dog);
  38.         thread.start();
  39.     }
  40. }
  42. class Animal{}
  43. class Dog extends Animal implements Runnable{
  44.     private int count;
  45.     @Override
  46.     public void run() {
  47.         while (true) {
  48.             System.out.println(Thread.currentThread().getName() + " hi~ " + (++count));
  49.             try {
  50.                 Thread.sleep(1000);
  51.             } catch (InterruptedException e) {
  52.                 e.printStackTrace();
  53.             }
  54.             if (count == 10) {
  55.                 break;
  56.             }
  57.         }
  58.     }
  59. }

使用实现Runnable接口的方式创建线程，其实底层是使用了代理模式这种设计模式，在后面设计模式会详细介绍，这里演示一个简单的案例。

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class Proxy_ {
  8.     public static void main(String[] args) {
  9.         Tiger tiger = new Tiger();
  10.         ThreadProxy threadProxy = new ThreadProxy(tiger);
  11.         threadProxy.start();
  12.     }
  13. }
  15. class Tiger extends Animal implements Runnable{
  16.     private int count;
  17.     @Override
  18.     public void run() {
  19.         while (true) {
  20.             System.out.println("老虎叫" + (++count) + "声~");
  21.             try {
  22.                 Thread.sleep(500);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             if (count == 10) break;
  27.         }
  28.     }
  29. }
  31. //代理模式 极简案例
  32. class ThreadProxy implements Runnable {  //模拟Thread
  34.     private Runnable target = null;
  36.     public ThreadProxy(Runnable i) {  //传入实现了Runnable的tiger
  37.         this.target = i;
  38.     }
  40.     @Override
  41.     public void run() {
  42.         if (target != null) {
  43.             target.run();  //动态绑定(类型是Tiger)
  44.         }
  45.     }
  47.     public void start() {
  48.         start0();  //这个方法时真正实现多线程方法
  49.     }
  51.     public void start0() {
  52.         run();
  53.     }
  54. }

2.4 线程使用应用案例 - 多线程执行

编写一个程序，创建两个线程，一个线程每隔1秒输出”hello,world”，输出10次退出；另一个线程每隔1秒输出”hello,java”，输出5次退出。

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class Thread02 {
  8.     public static void main(String[] args) {
  9.         PrintHello printHello = new PrintHello();
  10.         PrintJava printJava = new PrintJava();
  11.         printHello.start();
  12.         printJava.start();
  13.     }
  14. }
  15. class PrintHello extends Thread {
  16.     private int count;
  17.     @Override
  18.     public void run() {
  19.         while (true) {
  20.             System.out.println("hello,world " + (++count));
  21.             try {
  22.                 Thread.sleep(1000);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             if (count == 10) break;
  27.         }
  28.     }
  29. }
  30. class PrintJava extends Thread {
  31.     private int count;
  32.     @Override
  33.     public void run() {
  34.         while (true) {
  35.             System.out.println("hello,java " + (++count));
  36.             try {
  37.                 Thread.sleep(1000);
  38.             } catch (InterruptedException e) {
  39.                 e.printStackTrace();
  40.             }
  41.             if (count == 5) break;
  42.         }
  43.     }
  44. }

2.5 如何理解线程

image.png

2.6 继承 Thread 和实现 Runnable 接口的区别

  1. 从Java的设计来看，通过继承 Thread 或者实现 Runnable 接口来创建线程本质上没有区别，从 jdk帮助文档我们可以看到 Thread 类本身就实现了 Runnable 接口。
  2. 实现 Runnable 接口方式更加适合多个线程共享一个资源的情况，且避免了单继承的限制，建议用Runnable

案例演示：售票系统
编程模拟三个售票窗口售票100张，分别使用 继承Thread 和 实现 Runnable 方式 模拟，并分析存在的问题。

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0、
  6.  * 使用多线程，模拟三个窗口同时售票 100 张
  7.  */
  8. public class TicketSell {
  9.     public static void main(String[] args) {
  10.         /*
  11.         //使用 Thread
  12.         ThreadSell threadSell1 = new ThreadSell();
  13.         ThreadSell threadSell2 = new ThreadSell();
  14.         ThreadSell threadSell3 = new ThreadSell();
  15.         threadSell1.start();
  16.         threadSell2.start();
  17.         threadSell3.start();
  18.          */
  20.         //使用 Runnable
  21.         RunSell runSell = new RunSell();
  22.         new Thread(runSell).start();
  23.         new Thread(runSell).start();
  24.         new Thread(runSell).start();
  25.     }
  26. }
  27. class ThreadSell extends Thread {
  28.     private static int tickets = 10;
  29.     @Override
  30.     public void run() {
  31.         while (true) {
  32.             if (tickets > 0) {
  33.                 System.out.println(Thread.currentThread().getName() + " 窗口售出了一张票，剩余门票 " + (--tickets));
  34.                 try {
  35.                     Thread.sleep(50);
  36.                 } catch (InterruptedException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.             } else {
  40.                 System.out.println("票已售完...");
  41.                 break;
  42.             }
  43.         }
  44.     }
  45. }
  46. class RunSell implements Runnable {
  47.     private static int tickets = 100;
  48.     @Override
  49.     public void run() {
  50.         while (true) {
  51.             if (tickets > 0) {
  52.                 System.out.println(Thread.currentThread().getName() + " 窗口售出了一张票，剩余门票 " + (--tickets));
  53.                 try {
  54.                     Thread.sleep(50);
  55.                 } catch (InterruptedException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             } else {
  59.                 System.out.println("票已售完...");
  60.                 break;
  61.             }
  62.         }
  63.     }
  64. }

均存在的问题：售出票的总数大于实际票数，可能出现剩余票数为负数的情况

三、线程终止

3.1 基本说明

  1. 当线程完成任务后，会自动退出
  2. 还可以通过使用变量来控制 run 方法退出的方式停止线程，即通知方式

应用案例 - 使用通知方式控制线程停止

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class BreakThread {
  8.     public static void main(String[] args) {
  9.         WhileAll whileAll = new WhileAll();
  10.         whileAll.start();
  11.         //10秒后停止子线程
  12.         try {
  13.             Thread.sleep(10000);
  14.         } catch (InterruptedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         whileAll.setLoop(false);
  18.     }
  19. }
  21. class WhileAll extends Thread {
  22.     private int time;
  23.     private boolean loop = true;
  24.     @Override
  25.     public void run() {
  26.         while (loop) {
  27.             System.out.println(Thread.currentThread().getName() + " 线程已经运行 " + (++time) + " 秒");
  28.             try {
  29.                 Thread.sleep(1000);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.         }
  34.     }
  36.     public void setLoop(boolean loop) {
  37.         this.loop = loop;
  38.     }
  39. }

四、线程常用方法

4.1 常用方法第一组

setName 设置线程名称，使之与参数 name 相同
getName 返回该线程的名称
start 使该线程开始执行，即在JVM底层调用该线程的 start0 方法
run 调用线程对象 run 方法
setPriority 更改线程的优先级
getPriority 获取线程的优先级
sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
interrupt 中断线程（并非终止）

注意事项：

  1. start 底层会创建新的线程，调用 run，run就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
    MIN_PRIORITY = 1 最低优先级
    NORM_PRIORITY = 5 普通优先级

MAX_PRIORITY = 10 最高优先级

  1. interrupt：中断线程，但并没有真正的结束线程。一般用于中断正在休眠的线程使继续执行
  2. sleep：线程的静态方法，使当前线程休眠

应用案例：

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class ThreadMethod01 {
  8.     public static void main(String[] args) throws InterruptedException {
  9.         ThreadDemo01 td = new ThreadDemo01();
  10.         td.setName("小笼包");
  11.         td.setPriority(Thread.MIN_PRIORITY);
  12.         td.start();
  13.         //测试优先级
  14.         System.out.println("默认优先级 = " + Thread.currentThread().getPriority());
  15.         //测试interrupt
  16.         Thread.sleep(15000);
  17.         td.interrupt();
  18.     }
  19. }
  20. class ThreadDemo01 extends Thread {
  21.     @Override
  22.     public void run() {
  23.         for (int i = 0; i < 5; i++) {
  24.             System.out.println(Thread.currentThread().getName() + "吃包子~~~" + i);
  25.             try {
  26.                 System.out.println(Thread.currentThread().getName() + "休眠中...");
  27.                 Thread.sleep(10000);
  28.             } catch (InterruptedException e) {
  29.                 System.out.println(Thread.currentThread().getName() + "被 interrupt 了");
  30.             }
  31.         }
  32.     }
  33. }

4.3 常用方法第二组

yield 线程礼让。让出cpu，让其他线程执行，但礼让不一定成功，因为线程够用的情况下，不需要让出
join 线程插队。插入的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

案例演示：

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class ThreadMethod02 {
  8.     public static void main(String[] args) throws InterruptedException {
  9.         ThreadDemo02 tm = new ThreadDemo02();
  10.         tm.start();
  11. //        tm.join();  //线程插队
  12.         for (int i = 0; i < 20; i++) {
  13.             System.out.println("Main "+i);
  14.             Thread.sleep(1000);
  15.         }
  16.     }
  17. }
  18. class ThreadDemo02 extends Thread {
  19.     @Override
  20.     public void run() {
  21.         for (int i = 0; i < 20; i++) {
  22. //            Thread.yield();  //线程礼让
  23.             try {
  24.                 Thread.sleep(500);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.             System.out.println("JohnThread------" + i);
  29.         }
  30.     }
  31. }

小练习

  1. 主线程每隔1s,输出hi ,一共10次
  2. 当输出到hi 5时，启动一个子线程(要求实现Runnable),每隔1s输出hello ,等该线程输出10次hello后,退出
  3. 主线程继续输出hi，直到主线程退出. ```java package com.hspedu.thread.threaduse;

/**

  • @author HarborGao
  • @version 1.0 */ public class ThreadExercise01 { public static void main(String[] args) throws InterruptedException {
    1.  T t = new T();
    2.  Thread thread = new Thread(t);
    3.  for (int i = 0; i < 10; i++) {
    4.      System.out.println("主线程hi" + (i+1));
    5.      Thread.sleep(1000);
    6.      if (i == 4) {
    7.          System.out.println("启动子线程");
    8.          thread.start();
    9.          System.out.println("子线程插队");
    10.          thread.join();
    11.      }
    12.  }
    } } class T implements Runnable{ @Override public void run() {
    1.  for (int i = 0; i < 10; i++) {
    2.      System.out.println("子线程hello" + (i+1));
    3.      try {
    4.          Thread.sleep(1000);
    5.      } catch (InterruptedException e) {
    6.          e.printStackTrace();
    7.      }
    8.  }
    } } ```

4.4 用户线程和守护线程

  1. 用户线程：也叫工作线程，当线程的任务执行完成或通知方式结束
  2. 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
  3. 常见的守护线程：垃圾回收机制

应用案例：

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class ThreadMethod03 {
  8.     public static void main(String[] args) throws InterruptedException {
  9.         MyDaemonThread dt = new MyDaemonThread();
  10.         //将 dt 设置为守护线程,当所有线程结束后，dt也就自动结束
  11.         //如果没有设置，那么即使 main线程执行完毕，dt也不退出
  12.         dt.setDaemon(true);
  13.         dt.start();
  14.         for (int i = 0; i < 10; i++) {
  15.             Thread.sleep(1000);
  16.             System.out.println("沸羊羊在和灰太狼战斗... " + i);
  17.         }
  18.     }
  19. }
  20. class MyDaemonThread extends Thread {
  21.     @Override
  22.     public void run() {
  23.         for (;;) {
  24.             try {
  25.                 Thread.sleep(700);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println("喜羊羊与美羊羊在快乐的聊天~~~");
  30.         }
  31.     }
  32. }

五、线程的生命周期

5.1 JDK 中用 Thread.State 枚举了线程的几种状态

image.png

5.2 线程状态的转换图

image.png

5.3 案例演示 - 查看线程状态

  1. package com.hspedu.thread_.state_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class ThreadState {
  8.     public static void main(String[] args) throws InterruptedException {
  9.         T t = new T();
  10.         System.out.println(t.getName() + " 状态 " + t.getState());
  11.         t.start();
  12.         while (Thread.State.TERMINATED != t.getState()) {
  13.             System.out.println(t.getName() + " 状态 " + t.getState());
  14.             Thread.sleep(500);
  15.         }
  16.         System.out.println(t.getName() + " 状态 " + t.getState());
  17.     }
  18. }
  19. class T extends Thread {
  20.     @Override
  21.     public void run() {
  22.         while (true) {
  23.             for (int i = 0; i < 10; i++) {
  24.                 System.out.println("hi " + i);
  25.                 try {
  26.                     Thread.sleep(1000);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.             break;
  32.         }
  33.     }
  34. }

六、Synchronized

6.1 线程同步机制

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
  2. 也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

6.2 同步的具体方法 - Synchronized

  1. 同步代码块
    synchronized (对象) { //得到对象的锁，才能操作同步代码
    //需要被同步的代码
    }
  2. synchronized 还可以放在方法声明中，表示整个方法 - 为同步方法

public synchronized void m (String name) {
//需要被同步的代码
}

  1. 如何理解：

就好像某个小伙伴上厕所前把门关上（上锁），上完厕所再出来（解锁），其他小伙伴才可以依次使用厕所

6.3 使用 synchronized 解决前面的售票问题

  1. package com.hspedu.thread_.threaduse_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class TicketSell {
  8.     public static void main(String[] args) {
  9.         //使用 Runnable
  10.         RunSell runSell = new RunSell();
  11.         new Thread(runSell).start();
  12.         new Thread(runSell).start();
  13.         new Thread(runSell).start();
  14.     }
  15. }
  17. class RunSell implements Runnable {
  18.     private static int tickets = 10;
  19.     @Override
  20.     public void run() {
  21.         while (true) {
  22.             synchronized (this) {
  23.                 if (tickets > 0) {
  24.                     System.out.println(Thread.currentThread().getName() + " 窗口售出了一张票，剩余门票 " + (--tickets));
  25.                     try {
  26.                         Thread.sleep(50);
  27.                     } catch (InterruptedException e) {
  28.                         e.printStackTrace();
  29.                     }
  30.                 } else {
  31.                     System.out.println("票已售完...");
  32.                     break;
  33.                 }
  34.             }
  35.         }
  36.     }
  37. }

七、互斥锁

7.1 基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象
  3. 关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法（非静态的）的锁可以是 this，也可以是其他对象(要求是同一个对象启动的不同线程)
  6. 同步方法（静态的）的锁为当前类本身

7.2 代码演示

  1. package com.hspedu.syn;
  3. public class SellTicket {
  4.     public static void main(String[] args) {
  5.         SellTicket03 sellTicket03 = new SellTicket03();
  6.         new Thread(sellTicket03).start();//第1个线程-窗口
  7.         new Thread(sellTicket03).start();//第2个线程-窗口
  8.         new Thread(sellTicket03).start();//第3个线程-窗口
  9.     }
  10. }
  12. //实现接口方式, 使用synchronized实现线程同步
  13. class SellTicket03 implements Runnable {
  14.     private int ticketNum = 100;//让多个线程共享 ticketNum
  15.     private boolean loop = true;//控制run方法变量
  16.     Object object = new Object();
  18.     //同步方法（静态的）的锁为当前类本身
  19.     //解读
  20.     //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
  21.     //2. 如果在静态方法中，实现一个同步代码块.
  22.     /*
  23.         synchronized (SellTicket03.class) {
  24.             System.out.println("m2");
  25.         }
  26.      */
  27.     public synchronized static void m1() {
  29.     }
  30.     public static  void m2() {
  31.         synchronized (SellTicket03.class) {
  32.             System.out.println("m2");
  33.         }
  34.     }
  36.     //说明
  37.     //1. public synchronized void sell() {} 就是一个同步方法
  38.     //2. 这时锁在 this对象
  39.     //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
  40.     public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
  42.         synchronized (/*this*/ object) {
  43.             if (ticketNum <= 0) {
  44.                 System.out.println("售票结束...");
  45.                 loop = false;
  46.                 return;
  47.             }
  49.             //休眠50毫秒, 模拟
  50.             try {
  51.                 Thread.sleep(50);
  52.             } catch (InterruptedException e) {
  53.                 e.printStackTrace();
  54.             }
  56.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
  57.                     + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
  58.         }
  59.     }
  61.     @Override
  62.     public void run() {
  63.         while (loop) {
  64.             sell();//sell方法是一共同步方法
  65.         }
  66.     }
  67. }

7.3 注意事项和细节

  1. 同步方法如果没有使用 static 修饰：默认锁对象为 this
  2. 如果方法使用 static 修饰，默认锁对象：当前类.class
  3. 实现的落地步骤：
    1. 需要先分析上锁的代码
    2. 选择同步代码块或者同步方法
    3. 要求多个线程的锁对象为同一个即可

八、死锁

8.1 基本介绍

多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程时一定要避免死锁的发生

用一个例子体会：
妈妈：你先完成作业，才让你玩手机
小明：你先让我玩手机，我才完成作业

8.2 代码演示

  1. package com.hspedu.thread_.lock_;
  3. /**
  4.  * @author HarborGao
  5.  * @version 1.0
  6.  */
  7. public class DeadLock_ {
  8.     public static void main(String[] args) {
  9.         //模拟死锁现象
  10.         DeadLockDemo A = new DeadLockDemo(true);
  11.         DeadLockDemo B = new DeadLockDemo(false);
  12.         A.start();
  13.         B.start();
  14.     }
  15. }
  16. class DeadLockDemo extends Thread {
  17.     static Object o1 = new Object();
  18.     static Object o2 = new Object();
  19.     boolean flag;
  21.     public DeadLockDemo(boolean flag) {
  22.         this.flag = flag;
  23.     }
  25.     @Override
  26.     public void run() {
  27.         if (flag) {
  28.             synchronized (o1) {  //对象互斥锁，下面就是同步代码
  29.                 System.out.println(Thread.currentThread().getName() + "进入 o1");
  30.                 synchronized (o2) {  //这里获得li对象的监视权
  31.                     System.out.println(Thread.currentThread().getName() + "进入 o2");
  32.                 }
  33.             }
  34.         } else {
  35.             synchronized (o2) {
  36.                 System.out.println(Thread.currentThread().getName() + "进入 o2");
  37.                 synchronized (o1) {  //这里获得li对象的监视权
  38.                     System.out.println(Thread.currentThread().getName() + "进入 o1");
  39.                 }
  40.             }
  41.         }
  42.     }
  43. }

8.3 释放锁

下面操作会释放锁：

  1. 当前线程的同步方法、同步代码块执行结束
  2. 当前线程在同步代码块、同步方法中遇到 break、return
  3. 当前线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception，导致异常结束
  4. 当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁

下面的操作不会释放锁：

  1. 线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行
  2. 线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起

提示：应尽量避免使用 suspend() 和 resume() 来控制线程，方法不再推荐使用

九、本章作业

  1. 编程题
    1. 在 main 方法中启动两个线程
    2. 第一个线程循环随机打印100以内的整数
    3. 直到第二个线程从键盘读取了”Q”命令 ```java package com.hspedu.thread_.homework; import javax.swing.*; import java.awt.event.KeyEvent; import java.awt.event.KeyListener; import java.util.Scanner;

/**

  • @author HarborGao

  • @version 1.0 */ public class Homework01 extends JFrame { public static void main(String[] args) {

    1.  A a = new A();
    2.  B b = new B(a);
    3.  a.start();
    4.  b.start();

    } } class A extends Thread { private boolean loop = true; @Override public void run() {

    1.  while (loop) {
    2.      System.out.println((int)(Math.random() * 100 + 1));
    3.      try {
    4.          Thread.sleep(1000);
    5.      } catch (InterruptedException e) {
    6.          e.printStackTrace();
    7.      }
    8.  }
    9.  System.out.println("a线程退出..");

    }

    public void setLoop(boolean loop) {

    1.  this.loop = loop;

    } }

class B extends Thread { private A a; private Scanner scanner = new Scanner(System.in);

  1. public B(A a) {
  2.     this.a = a;
  3. }
  5. @Override
  6. public void run() {
  7.     while (true) {
  8.         System.out.println("请输入你的指令(Q表示退出)");
  9.         char key = scanner.next().toUpperCase().charAt(0);
  10.         if (key == 'Q') {
  11.             a.setLoop(false);
  12.             System.out.println("b线程退出...");
  13.             break;
  14.         }
  15.     }
  16. }

}

  2. 2. 编程题
  3.    1. 有2个用户分别从同一个卡上取钱（总额：10000）
  4.    1. 每次都取1000，当余额不足时，就不能取款了
  5.    1. 不能出现超取现象
  6. ```java
  7. package com.hspedu.thread_.homework;
  9. /**
  10.  * @author HarborGao
  11.  * @version 1.0
  12.  */
  13. public class Homework02 {
  14.     public static void main(String[] args) {
  15.         Bank bank = new Bank();
  16.         new Thread(bank).start();
  17.         new Thread(bank).start();
  18.     }
  19. }
  21. class Bank implements Runnable {
  22.     private static double money = 10000;
  24.     @Override
  25.     public void run() {
  26.         while (true) {
  27.             synchronized (this) {
  28.                 if (money <= 0) {
  29.                     System.out.println("余额不足...");
  30.                     break;
  31.                 }
  32.                 money -= 1000;
  33.                 System.out.println(Thread.currentThread().getName() + "取1000，剩余余额=" + money);
  34.             }
  35.             try {
  36.                 Thread.sleep(100);
  37.             } catch (InterruptedException e) {
  38.                 e.printStackTrace();
  39.             }
  40.         }
  41.     }
  42. }

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java