并发编程之ReentrantLock解析

是一种可重入同步互斥锁,其行为和语义和synchronized相同,但是对其进行了延申和升级,比如支持超时获取与公平策略,能响应线程中断,能够知道是否获取到了锁,更加灵活,效率更低.公平策略会降低吞吐量,但是能有效避免线程饥饿,在争用情况下，公平策略锁倾向于授予对等待时间最长的线程的访问权,避免线程争抢某个线程一直得不到CPU使用权.Lock不会像synchronized一样，异常的时候自动释放锁，所以最佳实践是，finally中释放锁，以便保证发生异常的时候锁一定被释放

源码分析

java.lang.Object
java.util.concurrent.locks.ReentrantLock


public class ReentrantLock
extends Object
implements Lock, Serializable


//构造方法
  /**
     * 创造一个ReentrantLock实例
     * 这相当于使用ReentrantLock(false),默认非公平策略
     */
    public ReentrantLock() {
 
        sync = new NonfairSync();
    }



 /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
    //FairSync和NonfairSync分别实现公平与非公平策略
        sync = fair ? new FairSync() : new NonfairSync();
    }


//重要方法

  * @return 当前线程对此锁的保持数，如果当前线程不保持此锁，则为零
  * 
     */
    public int getHoldCount() {
        return sync.getHoldCount();
    }



 /**
     * 确定公平策略是否开启,如果开启返回true否则返回false
     *   
     * 默认是false
     */
    public final boolean isFair() {
        return sync instanceof FairSync;
    }


 /**
     * 获取锁。
     * 如果锁未被另一个线程持有，则获取该锁并立即返回，将锁持有计数设置为1。
     * 如果当前线程已经持有锁，那么持有计数将增加1，并且方法立即返回。
     * 如果锁被另一个线程持有，则当前线程将因线程调度而禁用，并处于休眠状态，直到获得锁为止，此时锁持有计数
     * 设置为1。这里解释了Lock确实是一个重入锁
     */
    public void lock() {
        sync.lock();
    }


 /**
     * 获取锁，除非当前线程被中断。
     *
     * 如果锁未被另一个线程持有，则获取该锁并立即返回，将锁持有计数设置为1。
     * 
     * 如果当前线程已经持有此锁，则保持计数将增加1，并且方法将立即返回。
     *
     * 如果锁被另一个线程持有，则当前线程将被禁用以进行线程调度
     *
     * 
     *在获取锁时被中断，然后抛出InterruptedException并清除当前线程的中断状态。
     *在这个实现中，由于这个方法是一个显式的中断点，所以优先考虑响应中断，而不是对锁的正常或可重入获取。
     *
     * @throws InterruptedException i如果获取锁被打断
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }


 /**
     *尝试获取锁,支持重入操作,
     *如果获取成功返回true否则返回false,和lock()不同的是不会发生阻塞
     *公平策略对这个方法不起作用
     */
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }



/**
     *
     *在指定的时间内去获取lock,如果获取成功返回true否则返回false,这个方法支持公平策略,可重入,
     *响应中断
     * @throws InterruptedException 如果被中断
     * @throws NullPointerException 参数错误
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }


 /**
     * 由锁的持有者释放锁
     *
     * 释放时计数器减一,计数器为0才能释放
     *
     * @throws IllegalMonitorStateException 非持有者试图释放锁报错
     *         
     */
    public void unlock() {
        sync.release(1);
    }

案例分析

ArrayBlockingQueue重要方法分析

  /**
     *将指定的元素插入到此队列的尾部（如果立即可行且不会超过该队列的容量
     *在成功时返回 true，如果此队列已满，则返回 false
     *
     * @throws NullPointerException 如果插入的元素为空
     */
    public boolean offer(E e) {
        Objects.requireNonNull(e);
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
        //判断队列元素个数和数组的长度，如果相同队列满了，返回false
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
        //释放锁
            lock.unlock();
        }
    }


 /**
     * 将指定的元素加入队列，如果队列满了发生阻塞
     *
     * @throws InterruptedException {@inheritDoc}
     * @throws NullPointerException {@inheritDoc}
     */
    public void put(E e) throws InterruptedException {
        Objects.requireNonNull(e);
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lockInterruptibly();
        try {
            while (count == items.length)
            //当队列满了就阻塞
                notFull.await();
                //有可用空间就插入元素
            enqueue(e);
        } finally {
        //释放锁
            lock.unlock();
        }
    }