JUC - ReentrantLock 源码分析

简介

ReentrantLock，一个可重入的独占锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

源码分析

ReentrantLock的实现方式是在内部定义了一个实现AbstractQueuedSynchronizer（详见：JUC 源码分析 － AbstractQueuedSynchronizer(AQS)）的内部类Sync，Sync主要实现了AbstractQueuedSynchronizer中独占模式的获取和释放方法tryAcquire和tryRelease，在ReentrantLock中使用AQS的子类Sync，AQS的status代表锁是否被占用，为0代表没有被占用，大于0代表被当前线程占用的次数，每次占用必需要对应一次释放，ReentrantLock是可重入的锁，一个线程可以同时多次获取到锁。

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        abstract void lock();//主要为了子类可以尝试快速非公平的获取锁

        final boolean nonfairTryAcquire(int acquires) {//非公平尝试获取锁，公平与非公平实现的trylock方法都会调用这个来尝试非公平的获取一次
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//当前状态为0代表锁没有被获取，CAS设置状态，成功后setExclusiveOwnerThread设置持有锁的线程
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {//如果锁被占用，查看占用锁的线程是否是当前线程，当前线程可以再次获取锁
                int nextc = c + acquires;
                if (nextc < 0) //如果负值则快速失败
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {//释放锁
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())//释放锁的当前线程必须是持有锁的线程，否则无法释放
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//因为可重入，所以状态为0时才需要setExclusiveOwnerThread(null)清空持有锁的线程，并且返回true，返回true会在release方法触发唤醒等待锁的线程。只有当前线程完全释放锁，其他线程才可以去得到锁
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {//判断当前线程是否是持有锁的线程
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {//Condition是AQS的等待队列，类似Object的wait和notify，在下一节分析
            return new ConditionObject();
        }

        final Thread getOwner() {//获取当前持有锁的线程
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {//获取重入持有锁的次数
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {//获取当前是否被锁
            return getState() != 0;
        }

        /**
         * Reconstitutes this lock instance from a stream.
         * @param s the stream
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {//反序列化需要重置锁状态为0
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

ReentrantLock的实现有公平和非公平两种，主要区别就是在获取锁时，公平实现会检查同步队列是否有线程处在等待，有则获取失败进入同步队列中去等待，非公平实现则不会检查，新插入的线程可以和队列中等待最久的线程一起竞争锁的使用，非公平是默认的实现，因为减少了线程挂起和释放，线程上下文切换的开销，性能好，缺点是有可能造成锁饥饿，队列中的线程迟迟无法获取到锁。

    static final class NonfairSync extends Sync {//非公平实现
        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {
            if (compareAndSetState(0, 1))//非公平实现会尝试快速获取一次，获取失败则调用acquire调用非公平的实现正常获取。
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);//非公平的去尝试获取锁
        }
    }

    static final class FairSync extends Sync {//公平实现
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {//调用AQS的acquire()方法
            acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {//公平尝试获取锁
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//为0代表可以获取锁
                if (!hasQueuedPredecessors() && //公平和非公平的主要区别，检查是否队列中没有等待的线程
                    compareAndSetState(0, acquires)) {//队列中没有等待的线程才尝试CAS修改锁状态，目的是保证先来获取的一定先获取到。
                    setExclusiveOwnerThread(current);//成功则设置当前线程为锁持有线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {//如果锁被占用，查看占用锁的线程是否是当前线程，当前线程可以再次获取锁
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

使用方式

注意：unlock必需在finally块中，以保证锁的释放；lock必需在try{}finally外面，防止未获取到锁仍然做额外的释放。

public class ReentrantLockTest {

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try {
            Thread.sleep(1000l);//独占逻辑
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}