尚硅谷JUC#Condition 控制线程通信

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。

在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法。

使用Condition

使用Condition控制线程通信：

1、如果不使用synchronized关键字保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait() notify() notifyAll()来进行线程通信了
2、当使用lock对象来保证同步时，Java提供了一个Condition类来保持协调，使用Condition可以让那些已经得到lock对象却无法继续执行的线程释放lock对象，Condition对象也可以唤醒其他处于等待状态的进程。
3、Condition实例被绑定在一个Lock对象上。要获得Lock实例的Condition实例，调用Lock对象的newCondition()方法即可。

生产者和消费者案例

1. 使用synchronized、wait（）、notifyAll（）解决

package day2;

/**
 * 生产者消费者问题：使用synchronized、wait（）、notifyAll（）解决
 */

public class ProductorAndConsumerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor productor = new Productor(clerk);
        Consumer consumer = new Consumer(clerk);
        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(productor,"生产者C").start();
        new Thread(consumer,"消费者D").start();

    }
}

//商店
class Clerk{
    private int product =0;//库存初始值
    //进货
    public synchronized void get(){
        while (product>=1){//库存容量为1
            System.out.println("库存已满");
            try {
                this.wait();//等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
            this.notifyAll();//唤醒


    }

    //卖货
    public synchronized void sale(){
        while (product<=0) {
            System.out.println("售完");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            System.out.println(Thread.currentThread().getName()+":"+ --product);
            this.notifyAll();
    }

}

//生产者
class Productor implements Runnable{
    private Clerk clerk;
    public Productor(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);//模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.get();
        }
    }
}
//消费者
class Consumer implements Runnable{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

2. 使用Condition解决

/**
 * 生产者消费者问题：使用Lock lock =new ReentrantLock();
 *     Condition condition=lock.newCondition();解决
 */

public class ProductorAndConsumerTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Productor productor = new Productor(clerk);
        Consumer consumer = new Consumer(clerk);
        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(productor,"生产者C").start();
        new Thread(consumer,"消费者D").start();

    }
}

//商店
class Clerk{
    Lock lock =new ReentrantLock();
    Condition condition=lock.newCondition();

    private int product =0;//库存初始值
    //进货
    public synchronized void get(){
        lock.lock();
        try {
            while (product>=1){//库存容量为1
                System.out.println("库存已满");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+":"+ ++product);
                condition.signalAll();
        }finally {
            lock.unlock();
        }

    }

    //卖货
    public  void sale(){
        lock.lock();
        try{
            while (product<=0) {
                System.out.println("售完");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+":"+ --product);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

}

//生产者
class Productor implements Runnable{
    private Clerk clerk;
    public Productor(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);//模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.get();
        }
    }
}
//消费者
class Consumer implements Runnable{
    private Clerk clerk;
    public Consumer(Clerk clerk){
        this.clerk=clerk;
    }
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}