显示锁Lock和显示条件变量Condition用法

使用显示锁Lock和显示条件变量Condition实现的有界缓存

‍Lock是一种广义的内置锁，Condition也是一种广义的内置条件队列。‍

内置条件队列存在一些缺陷。每个内置锁都只能有一个相关的条件队列，因而多个线程可能在同一个条件队列上等待不同的条件谓词，并且在最常见的加锁模式下公开条件队列对象。

这些因素都使得无法满足在使用notifyAll时所有等待线程为同一类型的需求。如果想编写一个带有多个条件谓词的并发对象，或者想获得除了条件队列可见性的更多控制权，就可以使用显示的Lock和Condition而不是内置锁和内置条件队列，这是一种更灵活的选择。

Lock比内置锁提供了更为丰富的功能，Condition同样比内置条件队列提供了更丰富的功能：在每个锁上可能存在多个等待、条件等待可以是可中断的、基于时限的等待，以及公平的或非公平的队列操作。

与内置条件队列不同的是，对于每个Lock，可以有任意数量的Condition对象。Condition对象继承了相关的Lock对象的公平性，对于公平的锁，线程会依照FIFO顺序从Condition.await中释放。

下面这段程序给出了有界缓存的另一种实现，即‍‍使用两个Condition，分别为notFull和notEmpty‍‍，用于表示”非满“和”非空“两个条件谓词。当缓存为空时，take将阻塞并等待notEmpty，此时put向notEmpty发送信号，可以解除任何在take中阻塞的线程。

使用显示条件变量的有界缓存

package sync;

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

/**
 * Created with IntelliJ IDEA.
 * User: ASUS
 * Date: 14-9-1
 * Time: 下午9:20
 * To change this template use File | Settings | File Templates.
 */
public class ConditionBoundedBuffer<T> {


    protected final Lock lock = new ReentrantLock();

    //条件谓词：notFull
    private final Condition notFull = lock.newCondition();
    //条件谓词：notEmpty
    private final Condition notEmpty = lock.newCondition();
    private final T[] items;
    private int tail, head, count;

    protected ConditionBoundedBuffer(int size) {
        items = (T[]) new Object[size];
    }

    /**
     * 阻塞并直到notFull
     *
     * @param x
     * @throws InterruptedException
     */
    public void put(T x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) {
                // 阻塞，等待非满条件
                System.out.println("not full await");
                notFull.await();
            }

            items[tail] = x;
            if (++tail == items.length) {
                tail = 0;
            }

            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }


    /**
     * 阻塞并直到notEmpty
     *
     * @return
     * @throws InterruptedException
     */
    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                // 阻塞，等待非空条件
                System.out.println("not empty await");
                notEmpty.await(); //现在有界缓存为空，要等到非空状态才能取出元素
            }

            T x = items[head];
            items[head] = null;
            if (++head == items.length) {
                head = 0;
            }
            --count;
            notFull.signal(); //元素已被取出，通知非满状态
            return x;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String args[]) {

        final ConditionBoundedBuffer buffer = new ConditionBoundedBuffer(10);

        //线程t2打印缓存中的消息
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        System.out.println(buffer.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        //线程t1放入缓存消息
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        buffer.put(new String("sadsasd"));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        t2.start();
        t1.start();

    }
}

==================END==================