多线程

概念

进程：是正在运行的程序

  • 是系统进行资源分配和调用的独立单位
  • 每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

  • 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  • 多线程：一个进程如果有多条执行路径，则称为多线程程序

举例：

单线程程序：记事本程序（当修改配置时不能再编辑了） 多线程程序：扫雷程序（当操作游戏扫雷时时间一直在增加）

多线程的实现方案

构造器 描述
[Thread](#%3Cinit%3E())() 分配新的 Thread对象。
[Thread](#%3Cinit%3E(java.lang.Runnable))([Runnable](Runnable.html) target) 分配新的 Thread对象。
[Thread](#%3Cinit%3E(java.lang.Runnable,java.lang.String))([Runnable](Runnable.html) target, [String](String.html) name) 分配新的 Thread对象。
[Thread](#%3Cinit%3E(java.lang.String))([String](String.html) name) 分配新的 Thread对象。

方案1：继承Thread类

  • 定义一个类MyThread继承Thread类
  • 在MyThread类中重写run()方法
  • 创建MyThread类的对象
  • 启动线程

两个小问题：

  • 为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

  • run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用
start()：启动线程；然后由JVM调用此线程的run()方法

方式2：实现Runnable接口 **

  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  • 启动线程

多线程的实现方案有两种

  • 继承Thread类
  • 实现Runnable接口

相比继承Thread类，实现Runnable接口的好处

  • 避免了Java单继承的局限性

  • 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想 ```java class MyRunnable implements Runnable{ @Override public void run() {

    1.   for (int i = 0; i < 100; i++) {
    2.       System.out.println(Thread.currentThread().getName()+":"+i);
    3.   }

    } } public class ThreadDemo01 { public static void main(String[] args) {

    1.   MyRunnable my = new MyRunnable();
    3.   Thread t1 = new Thread(my);
    4.   Thread t2 = new Thread(my,"A线程");
    5.   t1.start();
    6.   t2.start();
    8.   //        MyThread thread1 = new MyThread();
    9.   //        MyThread thread2 = new MyThread();
    10.   //        thread1.setName("飞机");
    11.   //        thread2.setName("火车");
    13.   //        MyThread thread1 = new MyThread("飞机");
    14.   //        MyThread thread2 = new MyThread("高铁");
    15.   //        thread1.start();
    16.   //        thread2.start();

    } }

class MyThread extends Thread{ public MyThread(String name) { super(name); }

  1. @Override
  2. public void run() {
  3.     super.run();
  4.     for (int i = 0; i < 100; i++) {
  5.         System.out.println(super.getName()+":"+i);
  6.         //            System.out.println(getName()+":"+i);
  7.     }
  8. }

}

  1. <a name="KRYTt"></a>
  2. ### 设置和获取线程名称
  3. Thread类中设置和获取线程名称的方法 
  5. - void setName?(String name)：将此线程的名称更改为等于参数 name 
  6. - String getName?()：返回此线程的名称 
  7. - 通过构造方法也可以设置线程名称
  9. ![image.png](https://cdn.nlark.com/yuque/0/2020/png/1559629/1605062532683-68800dba-e790-4568-a1e3-3a586e73d657.png#align=left&display=inline&height=227&margin=%5Bobject%20Object%5D&name=image.png&originHeight=227&originWidth=508&size=31672&status=done&style=none&width=508)<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/1559629/1605062717186-b1db2003-d176-4690-a188-2b2d8e957738.png#align=left&display=inline&height=270&margin=%5Bobject%20Object%5D&name=image.png&originHeight=270&originWidth=455&size=26757&status=done&style=none&width=455)<br />如何获取main()方法所在的线程名称? 
  11. - public static Thread currentThread()：返回对当前正在执行的线程对象的引用
  12. <a name="Mj1TW"></a>
  13. ### 线程优先级
  14. <a name="N0Hvv"></a>
  15. #### 线程调度
  16. 线程有两种调度模型：
  18. - 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片 
  19. - 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些 
  21. Java使用的是抢占式调度模型；<br />假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的。
  22. <a name="AD1s1"></a>
  23. #### 优先级相关方法
  24. | **方法名** | **说明** |
  25. | --- | --- |
  26. | final int getPriority() | 返回此线程的优先级 |
  27. | final void setPriority(int newPriority) | 更改此线程的优先级 线程默认优先级是5；<br />线程优先级的范围是：1-10 |
  29. 线程优先级高仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时候才能看到你想要的效果。<br />**代码演示：**
  30. ```java
  31. public class ThreadPriority extends Thread {
  32.     @Override
  33.     public void run() {
  34.         for (int i = 0; i < 100; i++) {
  35.             System.out.println(getName() + ":" + i);
  36.         }
  37.     }
  38. }
  39. public class ThreadPriorityDemo {
  40.     public static void main(String[] args) {
  41.         ThreadPriority tp1 = new ThreadPriority();
  42.         ThreadPriority tp2 = new ThreadPriority();
  43.         ThreadPriority tp3 = new ThreadPriority();
  44.         tp1.setName("高铁");
  45.         tp2.setName("飞机");
  46.         tp3.setName("汽车");
  47.         //public final int getPriority()：返回此线程的优先级
  48.         System.out.println(tp1.getPriority()); //5
  49.         System.out.println(tp2.getPriority()); //5
  50.         System.out.println(tp3.getPriority()); //5
  51.         //public final void setPriority(int newPriority)：更改此线程的优先级
  52.         //    tp1.setPriority(10000); //IllegalArgumentException
  53.         System.out.println(Thread.MAX_PRIORITY); //10
  54.         System.out.println(Thread.MIN_PRIORITY); //1
  55.         System.out.println(Thread.NORM_PRIORITY); //5
  56.         //设置正确的优先级
  57.         tp1.setPriority(5);
  58.         tp2.setPriority(10);
  59.         tp3.setPriority(1);
  60.         tp1.start();
  61.         tp2.start();
  62.         tp3.start();
  63.     }
  64. }

线程控制

image.png
理解setDaemon：主线程死亡之后，守护线程会陆续死亡（注意：不是立即死亡）
理解join：这个线程死亡之后 其他线程才开始工作

image.png

image.png

线程生命周期

image.png

线程同步

卖票案例

1、案例需求：
某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
2、实现步骤：

  • 定义一个类 SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
  • 在 SellTicket类中重写run()方法实现卖票，代码步骤如下
  • 判断票数大于 0，就卖票，并告知是哪个窗口卖的
  • 卖了票之后，总票数要减 1
  • 票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
  • 定义一个测试类 SellTicketDemo，里面有main方法，代码步骤如下
  • 创建 SellTicket类的对象
  • 创建三个 Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
  • 启动线程

3、代码实现

  1. public class SellTicket implements Runnable {
  2.   private int tickets = 100;
  3.   //在SellTicket类中重写run()方法实现卖票，代码步骤如下
  4.   @Override
  5.   public void run() {
  6.     while (true) {
  7.       if (tickets > 0) {
  8.         System.out.println(Thread.currentThread().getName() + "正在出售第" +
  9. tickets + "张票");
  10.         tickets--;
  11.      }
  12.    }
  13.  }
  14. }
  15. public class SellTicketDemo {
  16.   public static void main(String[] args) {
  17.     //创建SellTicket类的对象
  18.     SellTicket st = new SellTicket();
  19.     //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
  20.     Thread t1 = new Thread(st,"窗口1");
  21.     Thread t2 = new Thread(st,"窗口2");
  22.     Thread t3 = new Thread(st,"窗口3");
  23.     //启动线程
  24.     t1.start();
  25.     t2.start();
  26.     t3.start();
  27.  }
  28. }

卖票案例的问题

  • 卖票出现了问题
    • 相同的票出现了多次
    • 出现了负数的票
  • 问题产生原因
    • 线程执行的随机性导致的

分析代码：

  1. public class ThreadSync {
  2.     public static void main(String[] args) {
  3.         SellTicket st = new SellTicket();
  4.         Thread t1 = new Thread(st, "窗口1");
  5.         Thread t2 = new Thread(st, "窗口2");
  6.         Thread t3 = new Thread(st, "窗口3");
  8.         t1.start();
  9.         t2.start();
  10.         t3.start();
  11.     }
  12. }
  14. class SellTicket implements Runnable {
  15.     private int tickets = 100;
  17.     @Override
  18.     public void run() {
  19.         //相同的票出现了多次
  20.         /*while (true) {
  21.             //tickets = 100
  22.             //t1,t2,t3
  23.             // 假设t1线程抢到CPU的执行权
  24.             if (tickets > 0) {
  25.                 try {
  26.                     Thread.sleep(100);
  27.                     //t1线程休息100ms
  28.                     // t2线程抢到CPU执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒（tickets=100）
  29.                     //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒（tickets=100）
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.                 //假设线程按照顺序醒过来
  34.                 //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
  35.                 System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
  36.                 //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
  37.                 //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
  38.                 tickets--;
  39.                 //如果这三个线程还是按照顺序来，这里就执行了3次tickets--的操作，最终票就变成了97
  40.             }else{
  41.                 break;
  42.             }
  43.         }*/
  45.         //出现了负数的票
  46.         /*while (true) {
  47.             //tickets = 1;
  48.             //t1,t2,t3
  49.             //假设t1线程抢到CPU的执行权
  50.             if (tickets > 0) {
  51.                 //通过sleep()方法来模拟出票时间
  52.                 try {
  53.                     Thread.sleep(100);
  54.                     //t1线程休息100毫秒
  55.                     //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100 毫秒
  56.                     //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100 毫秒
  57.                 } catch (InterruptedException e) {
  58.                     e.printStackTrace();
  59.                 }
  60.                 //假设线程按照顺序醒过来
  61.                 //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
  62.                 //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
  63.                 //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
  64.                 //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
  65.                 //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
  66.                 //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
  67.                 System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
  68.                 tickets--;
  69.             }else {
  70.                 break;
  71.             }
  72.         }*/
  73.     }
  74. }

synchronize解决数据安全问题

同步代码块解决方案

  • 安全问题出现的条件
    • 是多线程环境
    • 有共享数据
    • 有多条语句操作共享数据
  • 如何解决多线程安全问题呢 ?
    • 基本思想：让程序没有安全问题的环境
  • 怎么实现呢 ?
    • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
    • Java 提供了同步代码块的方式来解决

  • 同步代码块格式：

    1. synchronized (任意对象) {
    2.   //多条语句操作共享数据的代码
    3. }

    synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

  • 同步的好处和弊端

    • 好处：解决了多线程的数据安全问题
    • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

  • 代码演示： ```java public class ThreadSync2 { public static void main(String[] args) {

    1.   SellTicket st = new SellTicket();
    2.   Thread t1 = new Thread(st, "窗口1");
    3.   Thread t2 = new Thread(st, "窗口2");
    4.   Thread t3 = new Thread(st, "窗口3");
    6.   t1.start();
    7.   t2.start();
    8.   t3.start();

    } }

class SellTicket2 implements Runnable { private static int tickets = 100; private Object obj = new Object();

  1. @Override
  2. public void run() {
  3.     //加上同步synchronize
  4.     while (true) {
  5.         if (tickets % 2 == 0) {

// synchronized (obj) { // synchronized (this) { //同步方法的锁对象是this synchronized (SellTicket2.class) { //静态同步方法的锁对象是 类名.class if (tickets > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + “正在出售第” + tickets + “张票”); tickets—; } } }else{ sellTicket(); } }

  1. }
  2. //同步代码块
  3. /* public void sellTicket() {        
  4.     synchronized(obj){
  5.         if (tickets > 0) {
  6.             try {
  7.                 Thread.sleep(50);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
  12.             tickets--;
  13.         }
  14.     }
  15. }*/
  17. //同步方法
  18. /*public synchronized void sellTicket() {
  19.     if (tickets > 0) {
  20.         try {
  21.             Thread.sleep(10);
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  25.         System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
  26.         tickets--;
  27.     }
  28. }*/
  30. //同步静态方法
  31. public static synchronized void sellTicket() {
  32.     if (tickets > 0) {
  33.         try {
  34.             Thread.sleep(10);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  38.         System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
  39.         tickets--;
  40.     }
  41. }

}

  1. <a name="C6kah"></a>
  2. #### 同步方法解决方案
  4. - 同步方法：就是把synchronized关键字加到方法上
  5. ```java
  6. 修饰符 synchronized 返回值类型 方法名(方法参数) {
  7.     //多条语句操作共享数据的代码
  8. }

同步方法的锁对象是什么呢? this

  • 同步静态方法：就是把synchronized关键字加到静态方法上

    1. 修饰符 static synchronized 返回值类型 方法名(方法参数) {
    2.   //多条语句操作共享数据的代码
    3. }

    同步静态方法的锁对象是什么呢? 类名.class

    线程安全的类

    StringBuffer

  • 线程安全，可变的字符序列；

  • 从版本 JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步；

    1. //线程安全，可变的字符序列。 字符串缓冲区类似于String ，但可以进行修改。 在任何时间点它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来改变。
    2. StringBuffer sb = new StringBuffer();
    3. sb.append(1);
    4. sb.append("abc");
    5. sb.append('S');
    6. sb.append(true);
    7. //sb.append(1).append("abc").append('S').append(true);
    8. System.out.println(sb);
    9. System.out.println(sb.charAt(1));
    10. sb.delete(1,3);
    11. System.out.println(sb);
    12. System.out.println(sb.indexOf("true"));      //返回指定子字符串第一次出现的字符串中的索引
    13. sb.insert(1,"AAA");
    14. System.out.println(sb.reverse());
    15. System.out.println(sb.substring(1,4));

    Vector

  • 从 Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector；

    Hashtable

  • 该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值；

  • 从 Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable；

一般情况下我们可以直接使用Collections工具类的静态方法将ArrayList、HashMap转化为线程安全的同步类；

  1. List list = Collections.synchronizedList(new ArrayList());
  2. ...
  3. synchronized (list) {
  4.     Iterator i = list.iterator(); // Must be in synchronized block
  5.     while (i.hasNext())
  6.         foo(i.next());
  7. } 
  10. Map m = Collections.synchronizedMap(new HashMap());
  11. ...
  12. Set s = m.keySet();  // Needn't be in synchronized block
  13. ...
  14. synchronized (m) {  // Synchronizing on m, not s!
  15.     Iterator i = s.iterator(); // Must be in synchronized block
  16.     while (i.hasNext())
  17.         foo(i.next());
  18. }

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock。
Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

  • ReentrantLock 构造方法 | 构造器 | 描述 | | —- | —- | | [ReentrantLock](#%3Cinit%3E())() | 创建一个 ReentrantLock的实例。 |

  • 加锁解锁方法 | 方法 | 描述 | | —- | —- | | public void lock() | 获得锁 | | public void unlock() | 释放锁 |

  • 代码演示

    1. public class SellTicket implements Runnable {
    2.   private int tickets = 100;
    3.   private Lock lock = new ReentrantLock();
    4.   @Override
    5.   public void run() {
    6.       while (true) {
    7.           try {
    8.               lock.lock();
    9.               if (tickets > 0) {
    10.                   try {
    11.                       Thread.sleep(100);
    12.                   } catch (InterruptedException e) {
    13.                       e.printStackTrace();
    14.                   }
    15.                   System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
    16.                   tickets--;
    17.               }
    18.           } finally {
    19.               lock.unlock();        //注意：上锁之后一定要解锁
    20.           }
    21.       }
    22.   }
    23. }
    24. public class SellTicketDemo {
    25.   public static void main(String[] args) {
    26.       SellTicket st = new SellTicket();
    27.       Thread t1 = new Thread(st, "窗口1");
    28.       Thread t2 = new Thread(st, "窗口2");
    29.       Thread t3 = new Thread(st, "窗口3");
    30.       t1.start();
    31.       t2.start();
    32.       t3.start();
    33.   }
    34. }

    生产者消费者模型

    模型概述

    生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。
    所谓生产者消费者问题，实际上主要是包含了两类线程：
    一类是生产者线程用于生产数据
    一类是消费者线程用于消费数据
    为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
    消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
    image.png
    Object 类的等待和唤醒方法

方法名 说明
void wait() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify() 唤醒正在等待对象监视器的单个线程
void notifyAll() 唤醒正在等待对象监视器的所有线程

生产者和消费者案例

生产者消费者案例中包含的类：

  • 奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
  • 生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
  • 消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
  • 测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

①创建奶箱对象，这是共享数据区域
②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤启动线程

参考：https://www.jianshu.com/p/ab013a4d5878
https://www.cnblogs.com/zhi-xing/p/10435086.html

  1. package com.xjt.myThread.produceAndCustomer;
  3. public class ProduceCustomer {
  4.     public static void main(String[] args) {
  5.         Box box = new Box();
  7.         Producer producer = new Producer(box);
  8.         Customer customer = new Customer(box);
  10.         Thread t1 = new Thread(producer);
  11.         Thread t2 = new Thread(customer);
  12.         t1.start();
  13.         t2.start();
  14.     }
  15. }
  17. class Box {
  18.     private int milk;
  19.     //定义一个成员变量，表示奶箱的状态,默认没有牛奶
  20.     private boolean state = false;
  22.     //生产牛奶
  23.     public synchronized void put(int milk){
  24.         if(state){      //如果奶箱有牛奶就等待消费
  25.             try {
  26.                 wait();
  27.             } catch (InterruptedException e) {
  28.                 e.printStackTrace();
  29.             }
  30.         }
  31.         //如果没有牛奶就生产牛奶
  32.         this.milk = milk;
  33.         System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
  34.         //生产完毕之后，修改奶箱状态
  35.         state = true;
  36.         //唤醒其他等待的线程
  37.         notifyAll();
  38.     }
  40.     //消费牛奶
  41.     public synchronized void get(){
  42.         if(!state){      //如果奶箱没有牛奶就等待生产
  43.             try {
  44.                 wait();
  45.             } catch (InterruptedException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.         //如果有牛奶就消费牛奶
  50.         System.out.println("用户拿到第" + this.milk + "瓶奶");
  51.         //消费牛奶完毕之后，修改奶箱状态
  52.         state = false;
  53.         //唤醒其他等待的线程
  54.         notifyAll();
  55.     }
  56. }
  58. class Producer implements Runnable{
  59.     private Box b;
  61.     public Producer(Box b) {
  62.         this.b = b;
  63.     }
  65.     @Override
  66.     public void run() {
  67.         for (int i = 0; i < 10; i++) {
  68.             b.put(i);
  69.         }
  70.     }
  71. }
  73. class Customer implements Runnable{
  74.     private Box b;
  76.     public Customer(Box b) {
  77.         this.b = b;
  78.     }
  80.     @Override
  81.     public void run() {
  82.         while (true){       //只要有牛奶就一直消费
  83.             b.get();
  84.         }
  85.     }
  86. }