java显式锁之--ReentrantLock

前言

 

采用synchronized进行加锁，是由jvm内部实现的 称为：内置锁。从java1.5开始，jdk api引入了新锁API 他们都继承自Lock，称为：显式锁，比如今天的主题ReentrantLock。之所以称做显式锁，主要有两点原因：1、相对于内置锁是有jvm内部实现的，显式锁是在使用java api实现的，确切的说是基于AQS实现的（对AQS的理解可以点击这里）；2、使用Lock加锁，需要显式的加锁以及释放锁，相对于内置锁使用synchronized而言，要麻烦些。下面来看看ReentrantLock的基本用法：

 

public class ReentrantLockTest {
 
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try{
            //业务方法
        }catch (Exception e){
            //业务异常
        }finally {
            lock.unlock();
        }
    }
}

 

从表面上看，使用显式锁比使用内置锁更繁琐，需要手动调用lock加锁和unlock解锁，如果忘记unlock 就会导致其他线程永远无法获取到锁的严重错误。既然为何还要新增显式锁呢？

 

简单的讲，显式锁的内置锁的补充：显式锁Lock提供了中断锁、定时锁、可轮询等实现，这些都是内置锁synchronized不具备的；显式锁可以指定为公平锁或非公平锁，而内置锁synchronized锁是非公平的。使用synchronized加锁，有些情况下很容易导致死锁，在这种情况下改用显式锁定时功能 在一段时间没有获取到锁，就放弃获取锁 就可以避免死锁。

 

另外与内置锁还有一个明显不同的地方是，内置锁可以用在方法上，而显式锁只能用在代码块上，也就是说强制使用更细粒度的加锁。

 

可以说内置锁和显式锁是互补关系：显式锁不能用在方法上，而且容易忘记释放锁；内置锁不可中断，有些情况下容易产生死锁，另外内置锁无法实现公平锁。根据这些差异在自己的实际业务场景中选择性使用即可，需要说明下的是显式锁的性能比内置锁性能稍微好些。

 

理论总结到处结束，下面开始以ReentrantLock锁分析下显式锁的实现原理。主要包括：排它锁、公平锁、非公平锁、中断锁、延迟锁、轮询锁、重入锁的实现原理。

 

ReentrantLock实现原理

 

对AQS的实现

首先需要说明的ReentrantLock与内置锁一样都是排它锁，从名字上开是与内置锁一样是可重入的。ReentrantLock与前两篇文章中讲的Semaphore和CountDownLatch一样都是基于AQS实现的，只是Semaphore和CountDownLatch都是共享锁的实现方法，而ReentrantLock是排它锁实现，也就是说ReentrantLock的内部类在实现AQS时是对tryAcquire、tryRelease这两个方法进行扩展的。首先来看内部类Sync对AQS的实现(Sync还有两个子类，分别对应公平和非公平锁实现)：

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;
 
    //交给公平和非公平的子类去实现
    abstract void lock();
 
    //非公平的排它尝试获取锁实现
    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        //如果AQS的state为0说明获得锁，并且对state加1，其他线程获取锁时被阻塞
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
       
        //判断线程是不是重新获取锁，如果是 无需排队，对AQS的state+1处理，这就是重入锁的实现
        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队列阻塞
    }
 
    //公平的排它尝试释放锁实现
    protected final boolean tryRelease(int releases) {
        int c = getState() - releases;//对应重入锁而言，在释放锁时对AQS的state字段减1
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        if (c == 0) {//如果AQS的状态字段已变为0，说明该锁被释放
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
 
    //判断是否是当前线程持有锁
    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
 
    //获取条件队列
    final ConditionObject newCondition() {
        return new ConditionObject();
    }
 
    // Methods relayed from outer class
 
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }
 
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }
 
    final boolean isLocked() {
        return getState() != 0;
    }
 
    /**
     * 说明ReentrantLock是可序列化的
     */
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

 

 

非公平锁

非公平锁实现：

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() {
        //判断当前state是否为0，如果为0直接通过cas修改状态，并获取锁
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);//否则进行排队
    }
 
    //调用父类的的非公平尝试获取锁
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

 

非公平锁的实现很简单，在lock获取锁时首先判断判断当前锁是否可以用（AQS的state状态值是否为0），如果是 直接“插队”获取锁，否则进入排队队列，并阻塞当前线程。

 

公平锁

公平锁实现：

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
 
    final void lock() {
        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) {
            //AQS队列为空，或者当前线程是头节点 即可获的锁
            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;
    }
}

公平锁的实现，跟Semaphore一样在tryAcquire方法实现中通过hasQueuedPredecessors方法判断当前线程是否是AQS队列中的头结点或者AQS队列为空，并且当前锁状态可用 可以直接获取锁，否则需要排队。

 

重入锁

不论是公平锁还是非公平锁的实现中，在tryAcquire方法中判断如果锁已经被占用，都会判断是否是当前线程占用，如果是 可以再次获取锁（无需排队），并对AQS的state字段加1；在释放锁时每次都减1，直到为0时，其他线程在可用。顺便提一下内置锁synchronized也是可以重入的。

//重入锁实现
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
 

 

排它锁

从两个tryAcquire的实现可以看出ReentrantLock的排它锁实现，根本上是通过AQS的state字段保证的，每次获取锁时都是首先判断state是否为0，并且只有1个线程能获取到锁。这个特性与内置锁synchronized相同。

 

关于ReentrantLock对AQS的三个内部类实现分析完毕，接下来看下ReentrantLock的核心方法，实现都很简单基本都是直接调用FairSync或者NonfairSync对AQS的实现。比如lock和unlock方法：

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

 

延迟锁

延迟锁，指的是在指定时间内没有获取到锁，就取消阻塞并返回获取锁失败，由调用线程自己决定后续操作，比如放弃操作或者创建轮询获取锁。

public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        //调用AQS带延时功能获取方法
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

 

中断锁

tryLock(long timeout, TimeUnit unit)这个方法会抛出InterruptedException异常，可以用于实现中断锁，即等待的时间还未到，可以直接调用interrupt方法以中断获取锁。另外ReentrantLock还有一个方法可以实现中断锁，即：lockInterruptibly方法

public void lockInterruptibly() throws InterruptedException {
        //直接调用AQS的可中断获取方法
        sync.acquireInterruptibly(1);
    }

 

通过调用该方法获取锁跟lock方法一样，如果获取不到会阻塞，不同的是使用这个方法获取锁是可以在外部中断的，但lock方法不行。使用灵活使用可中断锁，可以防止死锁。

 

Ps：中断锁是对获取锁的中断，注意与线程被中断的区别（虽然本质上都是中断线程）。不管是使用显式锁还是内置锁的线程阻塞都是可以被中断的，而中断锁是指线程在获取锁的过程中被阻塞 可以中断现在继续排队获取锁的过程。中断锁：是中断获取锁排队阻塞，可以使用ReentrantLock的tryLock(long timeout, TimeUnit unit)、lockInterruptibly()这两个方法实现，而使用内置锁synchronized 如果线程已经在排队获取锁是无法被中断的；中断线程：是中断线程执行业务方法过程中的阻塞（如sleep阻塞，BlookingQueue阻塞）。

 

轮询锁

tryLock(long timeout, TimeUnit unit)这个方法延迟获取锁的方法，另外ReentrantLock还有一个非延迟也不阻塞的获取锁方法tryLock()，尝试获取锁，如果没有获取到直接反回false 不阻塞线程：

public boolean tryLock() {
        //默认只有非公平实现
        return sync.nonfairTryAcquire(1);
}

ReentrantLock不直接提供轮询锁api，但可以用tryLock(long timeout, TimeUnit unit)和tryLock() 这两个方法实现。即没有获取到锁，可以使用while循环 隔一段时间再次获取，直到获取到为止，这种方式是解决死锁的常用手段。这两个方法的使用区别：tryLock(long timeout, TimeUnit unit)不用在while中sleep，而tryLock()需要自己在while中sleep一会儿，减少资源开销。以tryLock()为例 实现轮询锁：

public class ReentrantLockTest {
 
    public static void main(String[] args) throws Exception{
        ReentrantLock lock = new ReentrantLock(true);
        while (true){
            if(lock.tryLock()){//这里不阻塞
                try{
                    System.out.println("执行业务方法");
                    //业务方法
                    return;
                }catch (Exception e){
                    //业务异常
                }finally {
                    lock.unlock();
                }
 
            }
            //如果没有获取到睡一会儿，再取锁
            Thread.sleep(1000);
        }
    }
}

ReentrantLock中还有一个重要方法newCondition获取“条件队列”方法，其作用类似使用内置锁时Object的wait、notify、notifyAll。这部分内容比较多，在这里就不展开讲解，后面抽时间单独总结下。另外ReentrantLock还有一些其他辅助方法，都比较好理解，就不一一列举，在使用过程中自行查阅即可。

 

总结

 

 

最后再强调下显式锁Lock与内置锁是互补关系，有些场景下只能使用内置锁（比如对方法加锁）；有些场景下只能使用Lock（比如 需要防止死锁、或者实现公平锁）。显式锁在java API中常用的还有读写锁ReentrantReadWriteLock，本次主要讲了重入锁ReentrantLock的实现原理和基本用法。