ReentrantLock源码解析

引言

---

相信接触过java并发编程的对锁都不陌生，本文将给出ReentrantLock（可重入锁）的具体使用以及相关源码的分析。

先看具体的使用吧：

public class ReentrantLockTest {

    private static int number = 0;

    ReentrantLock reentrantLock = new ReentrantLock();

    public void writer() {
        reentrantLock.lock();//获取锁
        try {
            number++;
        } finally {
            reentrantLock.unlock();//释放锁
        }
    }

    public void reader() {
        reentrantLock.lock();
        try {
            System.out.println(Thread.currentThread() + " " + number);
        } finally {
            reentrantLock.unlock();
        }
    }

    @Test
    public void run() {
        for (int i = 0; i < 100; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    writer();
                    reader();
                }
            });
            thread.run();
        }
        reader();
    }
}

从上面的代码可以看出，可通过ReentrantLock的lock()方法来获取锁，unLock()方法来释放锁。

ReentrantLock的实现依赖于AbstractQueuedSynchronizer（简称AQS），接下来就源码来做一些简要的分析。

---

ReentrantLock源码分析

开始分析源码之前我们先来看看ReentrantLock的类图（本文给出的类图仅包含待分析的源码部分）：

ReentrantLock相关源码分析：

ReentrantLock分为公平锁和非公平锁（不知道这两种锁的区别的读者可自行百度，我在此不再做详细的赘述），我们首先来分析公平锁的相关内容。

• 如何声明公平锁

  ReentrantLock提供带参构造方法可以声明公平锁

//不带参构造方法，只能声明非公平锁，在使用的时候需要注意
public ReentrantLock() {
    sync = new NonfairSync();
}
//带参构造方法，fair == ture：公平锁，fair == false：非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

• 公平锁加锁

  加锁方法lock()调用轨迹如下：

• ReentrantLock.lock();
• FairSync.lock();
• AbstractQueuedSynchronizer.acquire(int arg);
• ReentrantLock.tryAcquire(int acquires)

到tryAcquire方法调用时才真正加锁，我们着重看一下该方法的源码：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();//读取锁状态state值
    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;
    }//当前线程再次进入锁（可重入，state表示该线程进入的次数）
    return false;
}

• 公平锁解锁

  解锁方法unlock()调用轨迹如下：

• ReentrantLock.unlock();
• AbstractQueuedSynchronizer.release(int arg);
• Sync.tryRelease(int releases)

tryRelease方法被调用时，释放锁，它的源码如下：

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 == 0的时候表示当前没有线程获取到锁，并且，锁释放成功一定是当前线程的state == 0
}

接下来我们来看看非公平锁，非公平锁的释放与公平锁完全一样，在这里就不再做赘述了，我们着重看一下非公平锁的加锁调用。

调用轨迹如下：

• ReentrantLock.lock();
• NonfairSync.lock();
• AbstractQueuedSynchronizer.compareAndSetState(int expect, int update)

我们来看看加锁部分的源码：

final void lock() {
    if (compareAndSetState(0, 1))//判断当前是否已经有线程获取该锁
        setExclusiveOwnerThread(Thread.currentThread());//若没有线程占用该锁，把锁分配给当前线程
    else
        acquire(1);//尝试获得锁，获取不到锁需要到队列中等待
}

protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);//原子操作方式更新state变量，保证线程安全
}

---

后记

到这里，ReentrantLock的源码分析告一段落，后续文章还会给出AQS相关分析，分析它是如何来保证线程获取锁的顺序等。