生产者和消费者问题

一、生产者消费者问题

二、管程法

package PACDemo;

//生产者消费者模型，利用缓冲区（管程法）
//生产者，消费者，产品，缓冲区,
//生产者和消费者之间解耦，消费者不用关心生产者，生产者也不用关心消费者，他们只需要知道缓冲区中是否有产品
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer=new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();
    }
}

//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container) {
        this.container = container;
    }
    //生产
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("生产了第"+i+"只鸡");
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    //消费
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            Chicken chicken= container.pop();
            System.out.println("消费了-->第"+chicken.id+"只鸡");
        }
    }
}

//产品
class Chicken{
    int id;//产品编号
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens=new Chicken[10];
    //容器计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，需要等待消费者消费
        if (count==chickens.length){//多个生产者消费者用while
            //通知消费者消费，生产者等待
            try {
                this.wait();//拥有当前对象锁的线程等待，释放锁
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，需要丢入产品
        chickens[count] = chicken;
        count++;
        //可以通知消费者消费了
        notify();//唤醒随机一个对象锁的等待线程
        //this.notifyAll();//唤醒全部对象锁的等待线程
    }

    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if (count==0){//多个生产者消费者用while
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        //通知生产者生产
        this.notifyAll();
        return chicken;
    }

}

三、信号灯法（flag法）

package PACDemo;
//生产者消费者问题线程间通讯：解决方案二（信号灯法），通过标志位进行判断
public class TestPC2 {
    public static void main(String[] args) {
        TV tv=new TV();
        new Player(tv).start();
        new Audience(tv).start();
    }
}
//生产者：演员
class Player extends Thread{
    TV tv;
    public Player(TV tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                    tv.act("海贼王"+i);
            }else{
                    tv.act("斗破苍穹"+i);
            }
        }
    }
}
//消费者：观众
class Audience extends Thread {
    TV tv;
    public Audience(TV tv) {
        this.tv = tv;
    }
    @Override
    public void run() {
        for (int i = 0 ; i < 20; i++) {
                tv.see();
        }
    }
}
//仓库：TV
class TV{
    String progarm;//节目内容
    boolean flag=true;
    //演员表演
    public synchronized void act(String progarm)  {
        //先进行判断休眠，否则可能会造成死锁
        if (!flag){
            //线程休眠
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开始表演
        System.out.println("演员开始表演:"+progarm);
        this.progarm = progarm;
        notifyAll();
        this.flag=!this.flag;//转换标志位
        //演员表演完成唤醒观众
    }
    //观众观看
    public synchronized void see()  {
        if (flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //开始观看
        System.out.println("观众开始看:"+progarm);
        notifyAll();//演员表演完成唤醒观众
        this.flag=!this.flag;//转换标志位

    }
}

四、线程池

• 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

• 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。如设置最大线程数有5个，核心线程数有3个，当执行到第四个线程则需要在等待队列中等待，当执行到第7个，需要开启4个核心线程，当执行到8个，开启5个核心线程，当执行到第8个后，则根据设置的执行策略进行处理，如抛出异常或交给其他线程处理，如下。

  • 
  • 

• 好处：

  • 提高响应速度（减少了创建新线程的时间）
  • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
  • 便于线程管理等
    • corePoolSize：核心池大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

• 使用线程池：

  • JDK1.5提供了线程池相关API：ExecutorService和Executors
  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
    • void execute（Runnable command）：执行任务/命令，一般用来执行Runnable
    • Future submit(Callable task):执行任务，一般用来执行Callable
    • void shutdown():关闭连接池
  • Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

  package PACDemo;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  //线程池
  public class ThreadPoolTest {
      public static void main(String[] args) {
          //创建线程池
          ExecutorService service= Executors.newFixedThreadPool(2);//2代表核心线程数有2个最大线程数也是两个，无等待队列
          //总的来说，newFiexedThreadPool线程池是一个具有固定核心线程数，
          // 并且共享一个无边界的阻塞队列的线程池。在任何时候，最多具有固定的核心线程数在处理任务中。
          // 如果此时有任务继续被提交进来，且核心线程数都在处理任务中，那么这些新提交的任务就会被丢到阻塞队列中，
          // 等待被执行。如果任何线程由于执行过程中的失败而终止在关闭之前，则需要一个新线程代替执行后续任务。直到显式关闭之前，池中的线程将一直存在。
          //执行
          service.execute(new Test());
          service.execute(new Test());
          service.execute(new Test());
          service.execute(new Test());
          service.execute(new Test());
          service.execute(new Test());
          //结束
          service.shutdown();
      }
  }
  class Test implements Runnable{
      @Override
      public void run() {
          System.out.println(Thread.currentThread().getName());
      }
  }