等待唤醒机制&&线程池

为什么要处理线程间通信

多个线程并发执行时, 在默认情况下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 方法之后的地方恢复执行。
总结如下：
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态；
否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态
调用wait和notify方法需要注意的细节：
1.wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。
包子案例：

package cn.itcast.day02.demo08;
public class Baozi {
    String pi;
    String xian;
    boolean flag=false;
}

package cn.itcast.day02.demo08;

public class Baozipu extends Thread{
   //1.设置包子变量
    private Baozi bz;
   //2.使用带参数的构造方法，为这个包子赋值；
    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();
          }
          bz.flag=true;
          System.out.println("包子铺已经生产好了***"+bz.pi+bz.xian+"***包子，吃货可以吃了");

      }
     }
    }
}

package cn.itcast.day02.demo08;
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){
                 try {
                     bz.wait();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             //被唤醒之后执行的代码，吃包子
             System.out.println("吃货正在吃***"+bz.pi+bz.xian+"***包子");
             bz.flag=false;
             bz.notify();
             System.out.println("吃货已经把"+bz.pi+bz.xian+"***包子吃完了，包子铺开始生产包子了");
             System.out.println("---------------------------------------------");

           }


        }
    }
}

package cn.itcast.day02.demo08;

public class BaoziDemo {
    public static void main(String[] args) {
        Baozi bz=new Baozi();
        new Baozipu(bz).start();
        new Chihuo(bz).start();

    }
}

包子铺正在生产***薄皮三鲜***包子
包子铺已经生产好了***薄皮三鲜***包子，吃货可以吃了
吃货正在吃***薄皮三鲜***包子
吃货已经把薄皮三鲜***包子吃完了，包子铺开始生产包子了
---------------------------------------------
包子铺正在生产***冰皮虾仁***包子
包子铺已经生产好了***冰皮虾仁***包子，吃货可以吃了

线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
合理利用线程池能够带来三个好处：

1. 【降低资源消耗】。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2. 【提高响应速度】。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
3. 【提高线程的可管理性】。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
   线程池的过程：
   线程池:JDK1.5之后提供的
   java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
   Executors类中的静态方法:
   static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
   参数:
   int nThreads:创建线程池中包含的线程数量
   返回值:
   ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
   java.util.concurrent.ExecutorService:线程池接口
   用来从线程池中获取线程,调用start方法,执行线程任务
   submit(Runnable task) 提交一个 Runnable 任务用于执行
   关闭/销毁线程池的方法
   void shutdown()
   线程池的使用步骤:
   1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
   2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
   3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
   4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

package com.itheima.demo02.ThreadPool;
/*
    2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
 */
public class RunnableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建了一个新的线程执行");
    }
}

package com.itheima.demo02.ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Demo01ThreadPool {
    public static void main(String[] args) {
        //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
        es.submit(new RunnableImpl());//pool-1-thread-1创建了一个新的线程执行
        es.submit(new RunnableImpl());//pool-1-thread-2创建了一个新的线程执行

        //4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)
        es.shutdown();

        es.submit(new RunnableImpl());//抛异常,线程池都没有了,就不能获取线程了
    }

}