java基础之线程通信

线程通信
生产者消费者模式
    应用场景：生产者和消费者问题
        假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费
        如果仓库没有产品 则生产者将产品放入仓库 否则停止生产并等待 直到仓库中的产品被消费者取走为止
        如果仓库中有产品 则消费者将产品取走消费 否则停止消费并等待 直到仓库中再次放入商品为止
问题分析：
    这是个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间互为依赖，互为条件
    对于生产者 没有生产产品之前，要通知消费者等待，而生产了产品之后，又需要马上通知消费者
    对于消费者 在消费结束后 要通知生产者已经结束消费 需要生产者生产新的产品以供消费
    在生产者消费者问题中仅有synchronized是不够的
        synchronized可以阻止并发更新同一个共享资源，实现了同步
        synchronized不能实现不同线程之间的消息传递（通信)
Java提供了几个方法解决线程之间的通信问题
方法：
    wait()    表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
    wait(long timeout)   指定等待的毫秒数
    notify()   唤醒一个处于等待状态的线程
    notifyAll()  唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
    注意：均是Object类方法，都只能在同步方法或同步代码块中使用，否则会抛出异常IllegalMonitorStateException
解决方式一：
    并发协作模型"生产者/消费者"----->管程法
    生产者：负责生产数据的模块(可能是方法，对象，线程，进程)
    消费者：负责处理数据的模块(可能是方法，对象，线程，进程）
    缓冲区：消费者不能直接使用生产者的数据，他们之间有个"缓冲区"
    生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
Demo

//测试：生产者消费者模型--->利用缓冲区解决：管程法
//生产者，消费者，产品 缓冲区
public class Threadcomm_guancheng {
    public static void main(String[] args) {
        //缓冲区
        SynContainer container=new SynContainer();
        //生产者
        new Productor(container).start();
        //消费者
        new Consumer(container).start();
    }
}
//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
    //生产
    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;
    }
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println("消费了-->第"+container.pop().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){
            //通知消费者消费，生产者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满 就需要放入产品
        chickens[count]=chicken;
        count++;
        //可以通知消费者消费产品
        this.notifyAll();

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

    }
}
解决方式二：
    并发协作模型"生产者/消费者模式"----->信号灯法 设置标志位
Demo（有空再说）

public class Threadcomm_flag {
}
//生产者--->演员
class Player extends Thread{

}
//消费者---->观众
class Watcher extends Thread{

}
//产品-->节目
class TV{
    //节目
    String voice;
    boolean flag=true;
    //表演
    public synchronized void play(String voice){
        System.out.println("演员表演了："+voice);
        //通知观众观看
        //通知观众观看
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notifyAll();
        this.voice=voice;
        this.flag=!this.flag;
    }
    //观看
    public synchronized void  watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了-->"+voice);
        // 通知演员表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}

线程池
    背景 经常创建和销毁、使用量特别大的资源 比如并发情况下的线程，对性能影响很大
    思路：提前创建好多个线程，放入线程池，使用时直接获取，使用完放回池中
    可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
    好处：
        提高响应速度
        降低资源消耗
        便于线程管理
            corePoolSize：核心池大小
            maximumPoolSize：最大线程数
            KeepAliveTime：线程没有任务时最多保持多长时间后会终止
    JDK5.0开始提供了线程池相关API：ExecutorService和Executors
    ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor
        void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
        <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般用来执行Callable
        void shutdown()：关闭连接池
    Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

Demo

public class Thread_pool {

    public static void main(String[] args){
        //创建线程池
        //newFixedThreadPool 参数为：线程大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //关闭链接
        service.shutdown();
    }

}
class MyThread implements Runnable{

    @Override
    public void run() {

            System.out.println(Thread.currentThread().getName());

    }
}