java并发包之ReentrantLock

一、前言

在上文中谈到了AQS是Lock实现的前提，而本文说到的ReetrantLock就是在此基础上处理的。而本文中会对ReetrantLock公平性，可重入性等进行介绍。

二、特性

2.1 可重入

可重入性也就是能够让线程多次进行锁的获取操作，首先举个例子：

public class ReentranDemo {

    private ReentrantLock lock = new ReentrantLock();

    public void putDemo(){
        try {
            lock.lock();
            System.out.println("putDemo"+Thread.currentThread().getName());
            reInDemo();
        }finally {
            lock.unlock();
        }
    }

    public void reInDemo(){
        lock.lock();
        try {
            System.out.println("reInDemo"+Thread.currentThread().getName());
        }finally {
            lock.unlock();
        }
    }
     public static void main(String[] args) {
            new Thread(){
                public void run(){
                    new ReentranDemo().putDemo();
                }
            }.start();
    }
}

运行结果

putDemoThread-0
reInDemoThread-0

如果ReentrantLock不是可重入锁的话，那么该线程会进入死锁。

2.2 公平性

公平锁:线程获取锁资源的顺序为先后调用lock方法的顺序依次获取锁
非公平锁:加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待

看个例子：

public class FairLockDemo {

    private static Lock fairLock = new ReentrantLock(true);
    public void fair() {
        for (int i = 0; i < 5; i++) {
            new Thread(){
                public void run(){
                    for (int i = 0; i < 5; i++) {
                        fairLock.lock();
                        try {
                            System.out.println(Thread.currentThread().getName() + "is locking " );
                        } finally {
                            fairLock.unlock();
                        }
                    }
                }
            }.start();

        }

    }
    public static void main(String[] args) {
        FairLockDemo fairLockDemo = new FairLockDemo();
        fairLockDemo.fair();
    ｝  
}

返回结果如下：

Thread-0is locking 
Thread-1is locking 
Thread-2is locking 
Thread-3is locking 
Thread-0is locking 
Thread-4is locking 
Thread-1is locking 
Thread-2is locking 
Thread-3is locking 
Thread-0is locking 
Thread-4is locking 
Thread-1is locking 
Thread-2is locking 
Thread-3is locking 
Thread-0is locking 
Thread-4is locking 
Thread-1is locking 
Thread-2is locking 
Thread-3is locking 
Thread-0is locking 
Thread-4is locking 
Thread-1is locking 
Thread-2is locking 
Thread-3is locking 
Thread-4is locking 

如例子所示，连续获取的情况基本没有

2.3 非公平锁

加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待

看个例子：

public class UnfairLockDemo {

    private static Lock unfairLock = new ReentrantLock();

    public void unfair() {
        for (int i = 0; i < 5; i++) {
            new Thread(){
                public void run(){
                    for (int i = 0; i < 5; i++) {
                        unfairLock.lock();
                        try {
                            System.out.println(Thread.currentThread().getName() + "is locking " );
                        } finally {
                            unfairLock.unlock();
                        }
                    }
                }
            }.start();

        }

    }

    public static void main(String[] args) {
        UnfairLockDemo unfairLockDemo = new UnfairLockDemo();
        unfairLockDemo.unfair();
    }

}

返回结果如下：

Thread-0is locking 
Thread-3is locking 
Thread-3is locking 
Thread-3is locking 
Thread-3is locking 
Thread-4is locking 
Thread-4is locking 
Thread-4is locking 
Thread-4is locking 
Thread-4is locking 
Thread-1is locking 
Thread-1is locking 
Thread-1is locking 
Thread-1is locking 
Thread-1is locking 
Thread-2is locking 
Thread-2is locking 
Thread-2is locking 
Thread-2is locking 
Thread-2is locking 
Thread-0is locking 
Thread-0is locking 
Thread-0is locking 
Thread-0is locking 
Thread-3is locking 

而我们的非公平锁出现连续获取锁的情况却非常多。而出现这种情况的原因会在后文源码分析中介绍到。

三、主要类与方法分析

3.1 Sync

在看源码之前我们先略微介绍下该类，这个类是继承于AQS，而Sync还有两个子类，分别是公平锁和非公平锁的两种不同的实现。

 abstract static class Sync extends AbstractQueuedSynchronizer {

        //具体实现由非公平和公平进行实现
        abstract void lock();
        //非公平尝试获取
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取AQS锁资源的数量
            int c = getState();
            //如果为0表示没有线程获取资源
            if (c == 0) {
                //利用CAS将state为0修改为当前资源数，并将当前的线程记录下来
                if (compareAndSetState(0, acquires)) {       
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果state>0且当前线程和记录的线程是同一个，则重入处理（这里就是重入锁的相应实现）
            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;
        }
        //尝试释放锁资源
        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;
        }
        //是否独占
        protected final boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
        final ConditionObject newCondition() {
            return new ConditionObject();
        }
        //获取持有该锁的线程
        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }
        //获取重入的线程数
        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); 
        }
    }

nonfairTryAcquire在后文会看到非公平锁对其的调用，而内部实现的处理正是我们可重入锁的具体处理方案。

3.2 FairSync

接下来是我们的公平锁的类，他实现了其父类Sync的lock方法。也同时对上一篇文章AQS的tryAcquire进行了重写

static final class FairSync extends Sync {
        //获取锁，内部主要的实现由AQS的acquire实现
        final void lock() {
            //表示会获取一个锁资源，其中一部门就是由FairSync类下的tryAcquire实现具体实现可以看下上一篇文章AQS的acquire方法
            acquire(1);
        }
        //对基类AQS的重写，表示获取资源
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //状态为0表示没有线程获取锁
            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());
    }

由于lock的主要逻辑在AQS的acquire中，而tryAcquire方法的重写，展示了Reetrantlock公平锁在获取资源与其它同步锁不同的特性。通过调用的acquire表示其是一个独占锁，而通过判断当前线程与记录线程的比较实现的是Reetrantlock可重入性。而最后判断当前节点是否有前置节点来实现了我们的公平性。

3.3 NonfairSync

static final class NonfairSync extends Sync {
       
        final void lock() {
            //如果能获取锁直接获取。
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //获取不了通过nonfairTryAcquire进行锁资源获取
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            //sync类中有实现
            return nonfairTryAcquire(acquires);
        }
    }

公平锁和非公平锁的区别：
首先公平锁获取直接调用acquire方法，而该方法不是直接获取锁，而是调用的tryAcquire方法，而公平锁的tryAcquire首先获取state状态吐过没有线程占用（state＝0），会判断在AQS的等待队列中的该节点的前置节点是否为其他同样等待的节点，如果有就说明在公平性上其他节点已经排好队了，那么会让出获取资源的权利。
而非公平锁，一上来就直接判断state状态，完全是一种抢占的机制。如果抢占不了在调用acquire方法，而非公平的acquire中的tryAcquire同样不会像公平锁的tryAcquire方法判断节点的前置节点。

3.4构造函数

    public ReentrantLock() {
        sync = new NonfairSync();
    }

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

可以指定ReentrantLock的公平性

3.5 lock方法

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

直接调用公平锁或者非公平锁的lock

3.6 tryLock

public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

尝试获取锁，不会发生阻塞，成功或失败直接返回。

3.7 unlock

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

释放锁直接调用AQS的release释放。