ReentrantLock源码解析

1. 基本概念

ReentrantLock是一种排他锁,拥有synchronized的功能但是又比synchronized强大。ReentrantLock可以以公平或者非公平的方式去获取锁,默认采用非公平的方式去获取锁。本文主要讲解默认方式(非公平的去获取锁)

2. 继承关系

ReentrantLock实现了Lock和Serializable,所以ReentrantLock需要实现Lock的所有方法。

public interface Lock {
    /**
     * 获取锁,如果成功获取就马上返回,否着阻塞
     */
    void lock();

    /**
     * 获取锁,如果成功获取就马上返回,否着阻塞直到线程发生中断,如果发生中断请求就抛出InterruptedException
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 尝试着去获取锁,如果成功就立刻返回true否则立刻返回false,不会阻塞
     */
    boolean tryLock();

    /**
     * 在一定的事件内去获取锁,如果获取成功,就返回true,否则返回false,如果在尝试获取锁的过程中发生了中断,就抛出InterruptedException
    */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 释放锁
     */
    void unlock();

    /**
     *返回锁的Condition实例
     */
    Condition newCondition();
}

ReentrantLock里面还有一个静态的Sync继承了AbstractQueuedSynchronizer(AQS),实现了对锁的内部机制的封装。为了实现公平锁和非公平锁,又有NonfairSync和FairSync两个静态类继承Sync。AQS时ReentrantLock的主要实现原理,ReentrantLock中的方法都会最终调用AQS的方法。AQS时Java多线程中很重要的一个类,很多类都是基于AQS实现的,比如说CountDownLatch,Semaphore,ReentrantLock,ReentrantReadWriteLock等等。

如果需要使用AQS,就需要实现它的以下几个方法,不需要全部实现,只需要实现你要用的那几个:

  • tryAcquire
  • tryRelease
  • tryAcquireShared
  • tryReleaseShared
  • isHeldExclusively

ReentrantLock中的Sync类只实现了tryAcquire,tryRelease,isHeldExclusively方法。

3. 核心源码解析

1) ReentrantLock的lock方法解析

当调用ReentrantLock的lock方法时,会调用Sync的lock方法

//Sync
final void lock() {
    if (compareAndSetState(0, 1))// 将AQS中的state设置成1,主要0表示当前没有线程获取锁
        setExclusiveOwnerThread(Thread.currentThread()); // 将当前线程设置成拥有这个锁的线程
    else
        acquire(1);
}

acquire方法时AQS的核心方法, 采用模板设计模式。

// AQS
// 尝试去获取锁,如果获取失败就把线程放入链表中
// tryAcquire去尝试获取锁, 如果获取失败,就调用acquireQueued将当前想获取锁的线程放进链表中
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

使用非公平的方式去获取锁.

如果当前的锁没有被获取,就尝试获取锁,如果获取成功就返回true

如果当前的锁已经被获取了并且获取了的线程时当前线程,就更新state然后返回true

否则当前线程无法获取锁,返回false

// NonfairSync
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
// Sync
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//获取当前线程
    int c = getState();//获取state变量的值
    if (c == 0) {// 0 代表没有线程获取锁
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) { //检查已经获取到锁的线程是否时当前线程。如果是,更新state
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

AQS中维护着链表的head和tail。初始状态下都是null。

addWaiter将等待的线程加入链表中。

//AQS
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    if (pred != null) { //tail不是null, 代表链表已经初始化过了,将node添加到链表的末尾。
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //如果tail是null,说明链表还没有被初始化,使用enq方法进行初始化,并将node添加到链表中
    enq(node);
    return node;
}

//初始化链表并将node添加到链表中
//new一个Node作为head和tail,容后将node添加到tail的后面
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

acquireQueued是很重要的方法。

当node是最链表中的第二个节点(最应该获取锁的节点),就尝试获取锁,

如果获取失败或者node不是第二个节点(更靠后的节点),就用shouldParkAfterFailedAcquire检查是否应该park,如果需要park,就直接LockSupport.park(this),暂停这个线程。

如果线程在暂停状态,当调用lock的release方法去调用LockSupport.unpark(this)来启动这个线程。当线程再次启动之后,会检查这个线程是否被中断。

如果获取失败,就检查是否应该park,如果应该park就调用
//AQS
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)) {//如果p是head节点,说明当前线程是链表最前面的线程,然后尝试获取锁
                setHead(node);//获取锁成功后,将node设置成head,然后直接返回
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&//检查是否应该park
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

 

// Node
static final class Node{
    static final int CANCELLED =  1;
    static final int SIGNAL    = -1;
    static final int CONDITION = -2;
    static final int PROPAGATE = -3;
}

//AQS
//如果pred的waitSatatus是Node.SIGNAL,就返回true
//如果pred没有被中断,就设置为pred的waitStatus为Node.SIGNAL,并返回false
//如果pred被中断了,就从链表中清除这个节点,并返回false
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;
}

//调用LockSupport.park,暂停当前线程
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

2) ReentrantLock的unlock方法解析

当调用ReentrantLock的unlock方法时,会调用Sync的release方法

//Sync
//尝试release这个锁,如果release成功,就从链表中取出下一个节点并启动
//如果release失败(state比0大,锁还没有完全释放),就直接返回false
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);//  启动这个线程        return true;
    }
    return false;
}

释放锁,并更新state的状态

如果在释放之后,没有任何锁了,就返回true

//如果在释放之后,还有锁存在,就放回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;
}
//寻找需要启动的线程,并将其启动
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    Node s = node.next;    if (s == null || s.waitStatus > 0) {
 // s==null表明链表中没有其他的线程在等待锁,s.waitStatus > 0表明线程s已经被取消了,从队列的尾部查找是否有需要启动的线程        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值