ReentrantLock学习

基于独占模式的ReentrantLock（JDK1.8）

顶层接口

public interface Lock {
    // 加锁
    void lock();
    // 可打断的锁，当在获取不到锁等待时，可以被打断，直接返回
    // synchronized是不支持的，不会被打断
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    // 在time时间内尝试加锁
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    // 多个线程可以在不同的条件变量里等待
    Condition newCondition();
}

关键变量

private final Sync sync;

这个变量是用AQS同步器来实现的。提供了两种实现，一种是公平锁，一种是非公平锁。默认构造器是用了非公平锁。这里需要深刻理解公平和非公平的含义。

• 公平锁：我们现实世界里，遵循先来后到的原则才叫公平。每个线程来了，要先到后面去排队，不能直接去抢锁，这样每个线程都有可能获得锁。
• 非公平锁： 新来的线程先不去排队，直接和队列里的线程去抢锁，这样自然不公平的。但是性能好，新来的线程有一定概率是立刻获得锁的，但是可能造成队列里的线程很长时间都得不到锁。

原理直接源码

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1)) // 线程来了，直接进行CAS去修改状态变量的值
                setExclusiveOwnerThread(Thread.currentThread());
            else // 修改失败，才会去到AQS的加锁流程，尝试加锁 -》 入队
                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(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { // 未加锁状态
                if (!hasQueuedPredecessors() && // 队列里面没有线程去等待获取锁直接CAS设置锁，如果有的话就返回false了，说明AQS尝试加锁失败了，开始正式入队并加锁。
                    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; // AQS队列里面有线程，而且已经上锁了并且锁的所有者不是当前线程
        }
    }

关键方法

 public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquire(arg) ||
            doAcquireNanos(arg, nanosTimeout); // 这种逻辑运算的函数调用简直NB啊，tryAcquire失败，就正式的加锁
    }


private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                    nanosTimeout > spinForTimeoutThreshold) // 还有剩余时间, 直接睡眠，等待锁释放的时候或者是时间到了就唤醒
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

总结

• 宏观上来说，ReentrantLock在Java语言层面实现了一把锁，我们作为Java开发者, 可以去扩展，对我们更友好。
• 场景上来说，ReetrantLock支持公平锁和非公平锁，支持可打断的锁，支持一定时间内的加锁操作
• 原理上来说，ReentrantLock基于AQS, 使用状态变量waitStatus + CAS + 队列的来管理线程。

个人的思考

今天分析了ReentrantLock，发现同步器AQS才是重点，他为我们提供了一种抽象的框架，上层应用已经为我们写好了加锁的方法，唯一不同的是tryAquire方法的实现，这就是模板方法的应用，把不容易变的抽象到父类，形成一个模板，子类重写模板中的容易变的方法就好了。