015.2Condiction接口

Condiction对象能够让线程等待，也能够唤醒相应的线程，通过下面方法，具体看代码：
await();
signal();
signalAll();

使用步骤：
1）创建锁
2）通过锁拿到Condiction对象
3）Condiction对象等待后，就需要别人唤醒才会继续执行该进程

例子代码：

 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 public class NewProducerConsumerCondition
 {
 
     public static void main(String[] args)
     {
         Resource r = new Resource();
 
         //2,创建线程任务。
         Producer pro = new Producer(r);
         Consumer con = new Consumer(r);
 
         //3,创建线程。
         Thread t1 = new Thread(pro);
         Thread t2 = new Thread(pro);
         Thread t3 = new Thread(con);
         Thread t4 = new Thread(con);
 
         t1.start();
         t2.start();
         t3.start();
         t4.start();
     }
 
 }
 
 class Resource{
     private String name;
     private int count = 1;
     private final Lock lock = new ReentrantLock();
     private Condition produce = lock.newCondition();
     private Condition consume = lock.newCondition();
     private boolean flag = false;
     public void set(String name)
     {
         lock.lock();
         try{
             while(flag){
                 try{produce.await();}catch(Exception e){}        //Condiction对象等待
             }
             this.name = name + count;
             count += 1;
             System.out.println(Thread.currentThread().getName()+"-----生产者-------"+this.name);
             flag = true;
             consume.signalAll();
         }finally{
             lock.unlock();
         }
     }
 
     public void out()
     {
         lock.lock();
         try{
             while(!flag){
                 try{consume.await();}catch(Exception e){}
             }
             System.out.println(Thread.currentThread().getName()+"-----消费者-------"+this.name);
             flag = false;
             produce.signalAll();
         }finally{
             lock.unlock();
         }
     }
 }
 
 class Producer implements Runnable
 {
     private Resource r ;
     // 生产者一初始化就要有资源，需要将资源传递到构造函数中。
     Producer(Resource r)
     {
         this.r = r;
     }
     public void run()
     {
         while(true)
         {
             r.set("大白兔奶糖");
         }
     }
 }
 
 class Consumer implements Runnable
 {
     private Resource r ;
     // 消费者一初始化就要有资源，需要将资源传递到构造函数中。
     Consumer(Resource r)
     {
         this.r = r;
     }
     public void run()
     {
         while(true)
         {
             r.out();
         }
     }
 
 }

class BoundedBuffer
{
    final Lock lock = new ReentrantLock();// 锁
    final Condition notFull = lock.newCondition(); // 生产
    final Condition notEmpty = lock.newCondition(); // 消费
 
    final Object[] items = new Object[100];// 存储商品的容器。
    int putptr/* 生产者使用的角标 */, takeptr/* 消费者使用的角标 */, count/* 计数器 */;
 
    /* 生产者使用的方法，往数组中存储商品 */
    public void put(Object x) throws InterruptedException
    {
        lock.lock();
        try {
            while (count == items.length) // 判断计数器是否已到数组长度。满了。
                notFull.await();// 生产就等待。
 
            items[putptr] = x; // 按照角标将商品存储到数组中
 
            if (++putptr == items.length) // 如果存储的角标到了数组的长度，就将角标归零。
                putptr = 0;
            ++count;// 计数器自增。
            notEmpty.signal();// 唤醒一个消费者
        } finally {
            lock.unlock();
        }
    }
 
    public Object take() throws InterruptedException
    {
        lock.lock();
        try {
            while (count == 0) // 如果计数器为0，说明没有商品，消费者等待。
                notEmpty.await();
            Object x = items[takeptr]; // 从数组中通过消费者角标获取商品。
 
            if (++takeptr == items.length) // 如果消费的角标等于了数组的长度，将角标归零。
                takeptr = 0;
            --count;// 计数器自减。
            notFull.signal();// 唤醒生产者。
            return x;
        } finally {
            lock.unlock();
        }
    }
}

能存多个商品的店