java学习之高级语法（十八）----- 等待唤醒机制和线程池

 等待唤醒机制

▶  线程间通信

---  概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

例如：线程A用来生成包子，线程B用来吃包子，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生成，一个是消费，那么线程A与线程B之间就存在线程通信的问题。

---  为什么要处理线程间通信？

多个线程并发执行时，在默认情况下CPU是随机切换线程的，当需要多个线程来共同完成一件任务，并且希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来到达多线程共同操作一份数据。

---  如何保证线程间通信有效利用资源？

多个线程在处理同一资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作，就是多个线程在操作同一份数据时，避免对同一共享变量的争夺，即需要通过一定的手段使各个线程能有效的利用资源，这种手段就是---等待唤醒机制。

▶  等待唤醒机制

---  什么是等待唤醒机制？

这是多个线程间的一种协作机制。谈到线程经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是全部，线程间也会有协作机制 ；

就好比在公司里你和你的同事们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务；

在一个线程进行了规定操作后，就进入等待状态（wait()），等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）

在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

---  等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

（1）wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”，则在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中 ；

（2）notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座；

（3）notifyAll：则释放所通知对象的 wait set 上的全部线程。

【 注意： 哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。 】

总结如下：

（1）如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；

（2）如果不能获取锁 ，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

---  调用wait和notify方法需要注意的细节

（1）wait方法与notify方法必须要由同一个锁对象调用；

因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

（2）wait方法与notify方法是属于Object类的方法的；

因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。

（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用；

因为：必须要通过锁对象调用这2个方法。

编辑

▶  等待唤醒机制需求分析（以包子为例）：

编辑

/*
 生产者（包子铺）类：是一个线程类，可以继承Thread
       设置线程任务（run）：生产包子
       生产前对包子状态进行判断
         true:有包子 - 包子铺调用wait方法进入等待状态
         false:没有包子 - 包子铺生产包子
       增加一些趣味性：交替生产两种包子，有两种状态（i%2）
       包子铺生产好了包子，修改包子的状态为true有
       唤醒吃货线程，让吃货线程吃包子
 注意：
       包子铺线程和包子线程关系 ---> 通信（互斥）
       必须同时同步技术保证两个线程只能有一个在执行
       锁对象必须保证唯一，可以使用包子对象作为锁对象
       包子铺类和吃货类就需要把包子对象作为参数传递进来
       1.需要在成员位置创建一个包子变量
       2.使用带参数构造方法，为这个包子变量赋值
 */
public class BaoZiPu extends Thread {
  private BaoZi bz ;
  public BaoZiPu(BaoZi bz) {
    this.bz = bz ;
  }
  @Override
  public void run() {
    int count = 0;
    //必须同时同步技术保证两个线程只能有一个在执行
    while(true) {
      synchronized(bz) {
      if(bz.flag == true) {
        try {
          bz.wait();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    // 被唤醒之后执行，包子铺生产包子
    // 增加一些趣味性：交替生产两种包子
    if(count%2 == 0) {
      // 生产：薄皮三鲜馅包子
      bz.pi = "薄皮";
      bz.xian = "三鲜馅";
    }else {
      // 生产：冰皮牛肉大葱馅包子
      bz.pi = "冰皮";
      bz.xian ="牛肉大葱馅";
    }
    count++;
    System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    // 包子铺生产好了包子，则要修改包子状态为true
    bz.flag = true ;
    bz.notify();
    System.out.println("包子铺已经生成好了包子："+bz.pi+bz.xian+"包子，吃货可以吃包子了");
      }
    }
  }
}

/*
    资源类：包子类
                  设置包子的属性
                       皮
                       陷
                       包子的状态：有（true），没有（false）
 */
public class BaoZi {
  // 皮
  String pi;
  // 陷
  String xian;
  // 包子的状态：有（true），没有（false）
  boolean flag = false ;
}

public class ChiHuo extends Thread{
  private BaoZi bz;
  public ChiHuo(BaoZi bz) {
    this.bz = bz;
  }
  @Override
  public void run() {
    // 使用死循环，让吃货一直吃包子
    while(true) {
      // 必须同时同步技术保证两个线程只能有一个在执行
      synchronized(bz) {
        // 对包子的状态进行判断
        if(bz.flag == false) {
          // 吃货调用wait方法进入等待状态
          try {
            bz.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        // 被唤醒之后执行的代码-吃包子
        System.out.println("吃货正在吃："+bz.pi+bz.xian+"的包子");
        // 吃货吃完包子
        // 修改包子的状态为false没有
        bz.flag = false ;
        // 吃货唤醒包子铺线程 - 生成包子
        bz.notify() ;
        System.out.println("吃货已经吃完："+bz.pi+bz.xian+"的包子,包子铺开始生成包子");
        System.out.println("------------------------------------------");
      }
    }
  }
}

/*
 * 
    测试类：
           包含main方法，程序执行的入口，启动程序
           创建包子对象
           创建包子铺线程，开启，生成包子
           创建吃货线程，开启，吃包子
 */
public class Test {
  public static void main(String[] args) {
    // 创建包子对象
    BaoZi bz = new BaoZi() ;
    // 创建包子铺线程，开启，生成包子
    new BaoZiPu(bz).start() ;
    // 创建吃货线程，开启，吃包子
    new ChiHuo(bz).start();
  }
}

线程池

▶  线程池思想概述

我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是存在一个问题：

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，那么这样频繁的创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

有没有一种办法使得线程可以复用？ ---  线程池

复用就是执行完一个任务并不被销毁，而是可以继续执行其他任务。

▶  线程池的底层原理

编辑

▶ 线程池的工作原理图

编辑

▶  合理利用线程池能够带来三个好处

（1）降低资源消耗

        减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可以执行多个任务

（2）提高响应速度

        当任务到达时，任务可以不需要等到线程创建就能立即执行

（3）提高线程的可管理性

        可以根据系统的承受能力，调制线程池中工作线程的数目，防止因为消耗过多的内存，而把服务器累趴下（每个线程需要打约1MB内存，线程开的越多，消耗的内存也就越大，最后死机）

▶  线程池的产生

---  线程池是JDK 1.5之后提供的，在JDK 1.5之前没有提供线程池

---  java.util.concurrent.Executors ：线程池的工厂类，用来生成线程池

Executors类中的静态方法：

         static  ExecutorService newFixedThreadPool( int  nThread) --- 创建一个可复用的固定线程数的线程池

         参数： int  nThread  ---  创建线程池中包含的线程数量

         返回值：ExecutorService接口，返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口接收（面向接口编程）

---  java.util.concurrent.ExecutorService：线程池接口

       用来从线程池中获取线程，调用start方法，执行线程任务

              submit( Runnable task) 提交一个Runnable任务用于执行

       关闭/销毁线程池的方法

              void shutdown()

---  线程池的使用步骤：

（1）使用线程池的工厂类 Exexutors 里边提供的静态方法 newFixedThreadPool  生产一个指定线程数量的线程池

（2）创建一个类，实现 Runnable 接口，重写run方法，设置线程任务

（3）调用 ExecutorService 中的方法 submit ，传递线程任务（实现类）开启线程，执行 run 方法

（4）调用 ExecutorService 中的方法 shutdown 销毁线程池（不建议执行）

---  线程池的代码实现：

编辑

编辑