ReentrantLock那些事

前言

在说ReentrantLock之前，我们先说说并发吧。

在JDK1.5之前，并发处理常用的关键字synchronized。使用synchronized关键字，锁的获取和释放是隐式的，synchronized主要通过系统的monitorenter指令实现的。

那时候synchronized可以称为重量级锁，执行效率不是很高。

而Doug Lea编写的util.concurrent 包被纳入JSR-166标准。这里面就包含了ReentrantLock。

ReentrantLock为编写并发提供了更多选择。

使用

ReentrantLock的通常用法如下：

 public class X {
    private final ReentrantLock lock = new ReentrantLock();

    public void m() {
      lock.lock();  
      try {
        //TODO
      } finally {
        lock.unlock();
      }
    }
  }

原理

ReentrantLock主要是通过AbstractQueuedSynchronizer实现的，是一个重入锁，即一个线程加锁后仍然可以获得锁，不会出现自己阻塞自己的情况。

UML图

我们看一下它们的UML图。

可以看到ReentrantLock实现了Lock接口。

锁类型

ReentrantLock的两种锁类型，公平锁和非公平锁。

源码分析

我们先来看下ReentrantLock的构造方法。

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

可以看到默认无参构造方法为非公平锁实现。如果想定义公平锁实现，可以传入true来控制。

它的lock方法：

    public void lock() {
        sync.acquire(1);
    }
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

公平锁和非公平锁各有自己的实现方式。我们来看下他们的tryAcquire方法。

非公平锁源码：

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    final boolean nonfairTryAcquire(int acquires) {         
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

可以看到，非公平锁首先判断AQS（AbstractQueuedSynchronizer）中的state是否为0，0表示没有线程持有该锁，当前线程就尝试获取锁。

如果不是0，那在判断是不是当前线程持有该锁，如果是，就会增加state，改变state状态。（因此ReentranLock支持重入）。

公平锁源码：

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        @ReservedStackAccess
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    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;
        }
    }

    public final boolean hasQueuedPredecessors() {
        Node t = tail; 
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

公平锁的tryAcquire方法，可以看到，相比非公平锁，多了hasQueuedPredecessors方法，这个方法是判断队列中是否有其他线程，如果没有，线程才会尝试获取锁，如果有，会先把锁分配给队列的线程，因此称为公平锁。

这儿可以看到，非公平锁的效率比公平锁要高。

这是tryAcquire方法，如果尝试获取锁失败了呢？

那就会执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法啦。

我们先来看一下addWaiter方法。

    private Node addWaiter(Node mode) {
        Node node = new Node(mode);

        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

可以看到，这个方法会把线程添加到队列尾，同时，for(;;)循环保证添加成功，直到return出去。

添加后，调用acquireQueued方法，这个方法为挂起等待线程。

看下该方法源码：

    final boolean acquireQueued(final Node node, int arg) {
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } catch (Throwable t) {
            cancelAcquire(node);
            throw t;
        }
    }
    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

可以看到，如果节点为头节点，就尝试获取一次锁，如果成功，就返回。

否则判断该线程是否需要挂起，如果需要的化就调用parkAndCheckInterrupt挂起。

调用LockSupport.park方法挂起线程，直到被唤醒。

selfInterrupt方法：

    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();
        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                interrupt0();
                b.interrupt(this);
                return;
            }
        }
        interrupt0();
    }

调用interrupt方法，中断正在执行的线程（如果不是当前线程的话）。

释放锁unlock方法：

公平锁和非公平锁释放锁的方法是一样的。

    public void unlock() {
        sync.release(1);
    }
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            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) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

可以看到首先会判断当前线程是否是获得锁的线程，如果是重入锁需要将state减完才算是完全释放锁。

释放后调用unparkSuccessor唤起挂起线程。

总结

1. 非公平锁的效率是比公平锁要高的。
2. ReentranLock支持重入，因为增加了对自身线程的处理，通过state可以控制。
3. 解锁操作应放到finally块里，避免使用锁时出现资源无法释放的问题。