使用Condition实现生产者消费者

使用Condtion实现生产者消费者可以精确控制唤醒生产者还是消费者线程

与synchronized的等待唤醒机制相比Condition具有更多的灵活性以及精确性，这是因为notify()在唤醒线程时是随机(同一个锁)，而Condition则可通过多个Condition实例对象建立更加精细的线程控制，也就带来了更多灵活性了，我们可以简单理解为以下两点

通过Condition能够精细的控制多线程的休眠与唤醒。
对于一个锁，我们可以为多个线程间建立不同的Condition。

代码实现：

1、Condition提供了await()方法将当前线程阻塞，并提供signal()方法支持另外一个线程将已经阻塞的线程唤醒。
2、Condition需要结合Lock使用
3、线程调用await()方法前必须获取锁，调用await()方法时，将线程构造成节点加入等待队列，同时释放锁，并挂起当前线程
4、其他线程调用signal()方法前也必须获取锁，当执行signal()方法时将等待队列的节点移入到同步队列，当线程退出临界区释放锁的时候（ReentrantLock.unlock），唤醒同步队列的首个节点

资源：

package com.huige.review;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author liuhui
 * @description
 * @create 2018/10/18 上午11:22
 */
public class ResourceCondtion {
    private Lock lock = new ReentrantLock();
    private Condition consumeCondition = lock.newCondition();
    private Condition productCondition = lock.newCondition();
    private int number = 0;

    public  void increace(){
        lock.lock();
        try {
            while(number > 0){
                productCondition.await();
            }
            number ++;
            System.out.println("生产后"+Thread.currentThread().getName()+" : "+number);
            consumeCondition.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void decreace(){
        lock.lock();
        try {
            while(number == 0){
                consumeCondition.await();
            }
            number --;
            System.out.println("消费后"+Thread.currentThread().getName()+" : "+number);
            productCondition.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        ResourceCondtion resource = new ResourceCondtion();
        new Thread(new ProductCondition(resource)).start();
        new Thread(new ProductCondition(resource)).start();
        new Thread(new ConsumeCondition(resource)).start();
        new Thread(new ConsumeCondition(resource)).start();
        new Thread(new ConsumeCondition(resource)).start();
    }
}

生产者：

package com.huige.review;

/**
 * @author liuhui
 * @description
 * @create 2018/10/18 下午1:51
 */
public class ProductCondition implements Runnable {
    private  ResourceCondtion resource ;
    public ProductCondition(ResourceCondtion resource){
        this.resource = resource;
    }
    @Override
    public void run() {
        for (int i = 0;i<10;i++) {
            try {
                Thread.sleep(100);
            }catch (Exception e){

            }
            resource.increace();
        }
    }
}

消费者：

package com.huige.review;

/**
 * @author liuhui
 * @description
 * @create 2018/10/18 下午1:54
 */
public class ConsumeCondition implements Runnable{
    private  ResourceCondtion resource ;
    public ConsumeCondition(ResourceCondtion resource){
        this.resource = resource;
    }
    @Override
    public void run() {
        for (int i = 0;i<10;i++) {
            try {
                Thread.sleep(150);
            }catch (Exception e){

            }
            resource.decreace();
        }
    }
}

使用Condition实现生产者消费者

猜你喜欢