Java多线程——Lock、ReentrantLock和Condition

一、Lock接口

Lock接口相比于synchronized而言，Lock接口可以显示的，可中断的、定时获取锁。

public interface Lock {

void lock();   获取锁

void unlock(); 释放锁

void lockInterruptibly() throws InterruptedException;在获取锁的过程中能响应中断

boolean tryLock();  尝试非阻塞的获取锁，调用该方法后立刻返回。

boolean tryLock(long time, TimeUnit unit) throws InterruptedException; 在time时间内获取锁

Condition newCondition(); 获取Condition接口

}

二、ReentrantLock

ReentrantLock是Lock接口的具体实现类，内部使用AQS来实现其功能。

在其构造函数中添加了公平锁和非公平锁选项

公平锁按照线程请求锁的顺序来获取锁，反之则为非公平锁。

    public ReentrantLock() {
        sync = new NonfairSync();
    }

    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

从构造函数可以看出，默认为非公平锁，因为非公平锁开销更小，但容易产生“饥饿”。

ReentrantLock和synchronized的区别？

（1）ReentrantLock除了实现synchronized的语义之外，还增加了一些功能，包括尝试非阻塞的获取锁、可中断的获取锁，可定时的获取锁，公平锁。

（2）ReentrantLock需要显示的lock()和unlock()

（3）lock.newCondition()可以获得多个条件

（4）synchronized抛出异常时会主动释放锁

Condition接口

Condition接口的await(),singal(),singalAll()方法和Object的wait(),notify(),notifyAll()方法类似，调用wait(),notify(),notifyAll()需要synchronized锁住的监视器，同样的，调用await(),singal(),singalAll()方法需要相应的lock.

不同的是，一个lock可以有多个Condition。下面是用Condition条件实现的有界队列

public class BoundedQueue<T> {
    private Object[] items;

    // 添加的下标，删除的下标和数组当前数量
    private int addIndex,removeIndex,count;

    private Lock lock = new ReentrantLock();

    private Condition notEmpty = lock.newCondition();

    private Condition notFull = lock.newCondition();

    public BoundedQueue(int size){
        items = new Object[size];
    }

    /**
     * 添加一个元素，如果数组满，则添加线程进入等待状态，直到有"空位"
     */
    public void add(T t) throws InterruptedException{
        lock.lock();
        try{
            while(count == items.length){
                notFull.await();
            }
            items[addIndex] = t;
            if(++addIndex == items.length)
                addIndex = 0;
            ++count;
            notEmpty.signal();
        }finally{
            lock.unlock();
        }
    }

    /**
     * 由头部删除一个元素，如果数组空，则删除线程进入等待状态，直到有新添加元素
     */
    @SuppressWarnings("unchecked")
    public T remove() throws InterruptedException{
        lock.lock();
        try{
            while(count == 0)
                notEmpty.await();
            Object x = items[removeIndex];
            if(++removeIndex == items.length)
                removeIndex = 0;
            --count;
            notFull.signal();
            return (T)x;
        }finally{
            lock.unlock();
        }
    }
}