java并发编程充入锁：ReentrantLock

简述

ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它能够等同于synchronized的使用，可是ReentrantLock提供了比synchronized更强大、灵活的锁机制，能够减小死锁发生的几率。

API介绍以下：一个可重入的互斥锁定Lock，它具备与使用synchronized方法和语句所访问的隐士监视器锁定相同的一些基本行为和语义，但功能更强大。ReentrantLock将由最近成功得到锁定，而且没有释放该锁定的线程拥有。当锁定没有被另外一个线程所拥有时，调用Lock的线程将成功获取该锁定并返回。若是当前线程已经拥有该锁定，此方法将当即返回。可使用isHeldByCurrentThread() 和 getHoldCount() 方法来检查此状况是否发生。

ReentrantLock还提供了公平锁也非公平锁的选择，构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，不然为非公平锁。公平锁与非公平锁的区别在于公平锁的锁获取是有顺序的。可是公平锁的效率每每没有非公平锁的效率高，在许多线程访问的状况下，公平锁表现出较低的吞吐量。

获取锁

咱们通常都是这么使用ReentrantLock获取锁的：

//非公平锁
ReentrantLock lock = new ReentrantLock();
lock.lock();

lock方法：

public void lock() {
        sync.lock();
    }

Sync为ReentrantLock里面的一个内部类，它继承AQS（AbstractQueuedSynchronizer），它有两个子类：公平锁FairSync和非公平锁NonfairSync。

ReentrantLock里面大部分的功能都是委托给Sync来实现的，同时Sync内部定义了lock()抽象方法由其子类去实现，默认实现了nonfairTryAcquire(int acquires)方法，能够看出它是非公平锁的默认实现方式。下面咱们看非公平锁的lock()方法：

final void lock() {
        //尝试获取锁
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //获取失败，调用AQS的acquire(int arg)方法
            acquire(1);
    }

首先会第一次尝试快速获取锁，若是获取失败，则调用acquire(int arg)方法，该方法定义在AQS中，以下：

public final void acquire(int arg) {
         //tryAcquire获取锁不成功时，加入到队列中
         //不然，发生异常，自我中断
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

这个方法首先调用tryAcquire(int arg)方法，在AQS中讲述过，tryAcquire(int arg)须要自定义同步组件提供实现，非公平锁实现以下：

protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);//非公平锁
    }

    final boolean nonfairTryAcquire(int acquires) {
        //当前线程
        final Thread current = Thread.currentThread();
        //获取同步状态
        int c = getState();
        //state == 0,表示没有该锁处于空闲状态，此时从新判断状态，查看是否有锁
        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;
    }

释放锁

获取同步锁后，使用完毕则须要释放锁，ReentrantLock提供了unlock释放锁：

public void unlock() {
        sync.release(1);
    }

unlock内部使用Sync的release(int arg)释放锁，release(int arg)是在AQS中定义的：

public final boolean release(int arg) {
        //若是锁释放成功，则调取下一个等待节点
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

AQS的unparkSuccessor 方法，获取等待队列中的节点。

private void unparkSuccessor(Node node) {
    //这里，node通常为当前线程所在的结点。
    int ws = node.waitStatus;
    if (ws < 0)//置零当前线程所在的结点状态，容许失败。
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;//找到下一个须要唤醒的结点s
    if (s == null || s.waitStatus > 0) {//若是为空或已取消
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)//从这里能够看出，<=0的结点，都是还有效的结点。
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);//唤醒
}

与获取同步状态的acquire(int arg)方法类似，释放同步状态的tryRelease(int arg)一样是须要自定义同步组件本身实现：

protected final boolean tryRelease(int releases) {
        //减掉releases
        int c = getState() - releases;
        //若是释放的不是持有锁的线程，抛出异常
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        //state == 0 表示已经释放彻底了，其余线程能够获取同步状态了
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }

只有当同步状态完全释放后该方法才会返回true。当state == 0 时，则将锁持有线程设置为null，free= true，表示释放成功。

公平锁与非公平锁

公平锁与非公平锁的区别在于获取锁的时候是否按照FIFO的顺序来。释放锁不存在公平性和非公平性，上面以非公平锁为例，下面咱们来看看公平锁的tryAcquire(int arg)：

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;
    }

比较非公平锁和公平锁获取同步状态的过程，会发现二者惟一的区别就在于公平锁在获取同步状态时多了一个限制条件：hasQueuedPredecessors()，定义以下：

public final boolean hasQueuedPredecessors() {
        Node t = tail;  //尾节点
        Node h = head;  //头节点
        Node s;
        
        //头节点 != 尾节点
        //同步队列第一个节点不为null
        //当前线程是同步队列第一个节点
        return h != t &&
                ((s = h.next) == null || s.thread != Thread.currentThread());
    }

该方法主要作一件事情：主要是判断当前线程是否位于CLH同步队列中的第一个。若是是则返回true，不然返回false。（判断是不是等待时间最长的哪个。）

ReentrantLock与synchronized的区别

前面提到ReentrantLock提供了比synchronized更加灵活和强大的锁机制，那么它的灵活和强大之处在哪里呢？他们之间又有什么相异之处呢？ 首先他们确定具备相同的功能和内存语义。