Java常用多线程之间的通信方式

一、使用Object类的wait()、  notify() 、notifyAll()

wait()  告知被调用的线程放弃管程进入睡眠，直到其他线程进入相同管程并且调用notify()

notify() 恢复相同对象中第一个调用wait()的线程

notifyAll() 恢复相同对象中所有调用wait()的线程，具有最高优先级的线程最先运行

wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

public class TestPC {
    //生产者、消费者模型 管程法-利用缓存区解决
    //生产者、消费者、产品、缓存区
    //wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁
}
//生产者
class Productor extends  Thread{
    Cache cache;
    public Productor(Cache cache){
        this.cache=cache;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            cache.push(new Car(i) );
            System.out.println("生产了第"+i+"辆车");
        }
    }
}
//消费者
class Customer extends Thread{
    Cache cache;
    public Customer(Cache cache){
        this.cache=cache;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 1; i < 100; i++) {
            int  a=cache.get().id;
            System.out.println("买了第"+a+"辆车");
        }
    }
}
//产品
class Car{
    int id;//产品id
    public Car(int id) {
        this.id = id;
    }
}
//缓存区
class Cache{
    //缓存区大小
    Car[] cars=new Car[10];
    // 容器计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Car car){
       //缓存区满了，就需要等待消费者消费
        //if(count==10){
            while(count==cars.length){
            //通知消费者进行消费，生产者等待
            try {
                this.wait();
                this.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            //如果没有满，把生产的产品存入缓存区
            cars[count]=car;
            count++;
            //通知消费者消费了
            this.notifyAll();

    }

    //消费者消费产品
    public synchronized Car get(){
        //判断能否消费
        while(count==0){
            //等待生产者生产，消费者等待
            try {
                //Thread.sleep(100);
                this.wait();
                this.notifyAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            //如果可以消费,缓存区数量减少1，
            count--;
            Car car=cars[count];
            //消费之后，通知生产者生产
            this.notifyAll();
        return car;
    }

    public static void main(String[] args) {
        Cache cache=new Cache();
        new Productor(cache).start();
        new Customer(cache).start();
    }
}

结果：

生产了第1辆车
生产了第2辆车
生产了第3辆车
生产了第4辆车
生产了第5辆车
生产了第6辆车
生产了第7辆车
生产了第8辆车
生产了第9辆车
生产了第10辆车
生产了第11辆车
买了第10辆车
生产了第12辆车
买了第11辆车
生产了第13辆车
买了第12辆车
生产了第14辆车
买了第13辆车
生产了第15辆车
买了第14辆车
......

生产了第96辆车
买了第95辆车
生产了第97辆车
买了第96辆车
生产了第98辆车
买了第97辆车
生产了第99辆车
买了第98辆车
买了第99辆车
买了第9辆车
买了第8辆车
买了第7辆车
买了第6辆车
买了第5辆车
买了第4辆车
买了第3辆车
买了第2辆车
买了第1辆车