多线程学习--关于ReentrantLock源码详细解读

对于源码的阅读,有几点总结:

1.跑不通的源码,不读;

2.解决问题为目的;

3.总体把握,先不扣细节;

4.抓住一条线,往下阅读

话不多说,简单demo断点调试,JDK版本为1.8

public class TestReentrantLock {

    private static volatile int i = 0;

    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();    //在此打断点
        i++;
        lock.unlock();
    }
}

首先,关于重要方法的类的继承关系图如下

整体方法调用流程如下图

由lock.lock()方法进入到ReentrantLock类中,得到lock()方法的实现其实是调用了sync.lock();此方法是由Sync的子类NonfairSync实现的。源码如下

final void lock() {
   if (compareAndSetState(0, 1))
        //如果抢到锁,设置为私有
       setExclusiveOwnerThread(Thread.currentThread());
   else
        //没抢到锁,进入等待队列
       acquire(1);
}

通过CAS来获取锁,如果抢到锁,就设为私有,由此可见ReentrantLock是排他锁;

如果没抢到,则进入等待队列;我们来继续看看acquire()方法,源码如下

//tryAcquire(arg):
//acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
//addWaiter()
//没抢到锁,并且加入到等待队列的尾部
if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
     selfInterrupt();

其中条件中有三个方法,依次为tryAcquire()、acquireQueued()和addWaiter();

1.先看tryAcquire()方法,见名知意尝试获得,尝试去获得锁。它是通过ReentrantLock类中的内部类NofairSync实现的;调用了nonfairTryAcquire()方法;源码如下

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { //如果没加锁
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);  //抢到锁,设置私有
                    return true;
                }
            }
            //有锁,是自己线程的,重入,c+acquires
            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;
        }

由源码可知,如果是第一次获得锁,那就设为私有;如果此线程已经抢到锁,那么就将state状态修改,c+acquires,即+1,由此可见ReentrantLock是可重入锁

2.再看addWaiter()方法,关键,源码如下

    private Node addWaiter(Node mode) {
        //node为当前线程
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

prev:代表前一个节点

next:代表后一个节点

tail:代表尾部节点

由if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))理解,如果!tryAcquire(arg)为true,即没获取到锁,那么将进入等待队列。

addWaiter()即将此节点加入到等待队列的尾部;node为当前节点,将原队列的尾部节点赋值给pred节点,如果不为空,则将node节点的前一个节点指向pred(即原队列的尾部节点)

然后进行CAS进行设置,如果没有其他节点加入进来,那么此节点加入成功,pred(即原尾部节点)的下一个节点指向node,即将node加入到了原队列的尾部

3.acquireQueued()方法,获得等待队列;源码如下

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();  //node的前任节点
                if (p == head && tryAcquire(arg)) {  //前任节点是头节点,并且得到锁
                    setHead(node);                              //将node设置为头节点
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

shouldParkAfterFailedAcquire()方法源码如下:

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

parkAndCheckInterrupt()方法源码如下:

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

关于ReentrantLock源码的简单理解,希望各路大神多多指点。

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页