ReentrantLock源码解析

最新推荐文章于 2024-08-05 00:13:56 发布
最新推荐文章于 2024-08-05 00:13:56 发布
阅读量121 收藏
点赞数
分类专栏： ReentrantLock java 多线程方法 文章标签： Java ReentrantLock 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38910645/article/details/103511265
版权

ReentrantLock的使用

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
//    private static Lock lock =new ReentrantLock(false);
    private static Lock lock =new ReentrantLock(true);
public static void main(String[] args) {
    for (int i = 0; i < 5; i++) {
        new Thread(new ThreadDemo(i)).start();
    }
}
static class ThreadDemo implements Runnable{
    Integer id;

    public ThreadDemo(Integer id){
        this.id = id;
    }

    @Override
    public void run() {
        try{
            TimeUnit.MICROSECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 2; i++) {
            lock.lock();
            System.out.println("获得锁的线程：" + id);
            lock.unlock();
        }
    }
}
}

Lock接口源码解析

ReentrantLock实现了Lock接口：

public interface Lock {
    //加锁
    void lock();
    //加锁并响应中断
    void lockInterruptibly() throws InterruptedException;
    //只有空闲的才能获取锁，返回boolean值
    boolean tryLock();
    //在指定时间内获取锁，可以响应中断
    boolean tryLock(long var1, TimeUnit var3) throws InterruptedException;
    //解锁
    void unlock();
    //返回Condition对象
    Condition newCondition();
}

ReentrantLock内部类源码解析

在这里插入图片描述
说明：ReentrantLock类内部共存在Sync、NonfairSync、FairSync三个内部类，NonfairSync和FairSync继承自Sync，Sync继承自AbstractQueuedSynchronizer抽象类。

内部类Sync类源码解析

/**
*重入锁基础的同步控制器
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;
    //加锁方法，由子类FairSync、NonfairSync实现
    abstract void lock();
    //非公平方式加锁
    @ReservedStackAccess
    final boolean nonfairTryAcquire(int acquires) {
        //当前线程
        Thread current = Thread.currentThread();
        //获取锁的状态，即AQS中的state状态
        int c = this.getState();
        //c == 0表示没有线程持有该锁
        if (c == 0) {
            //CAS修改state状态，如果CAS成功，即加锁成功
            if (this.compareAndSetState(0, acquires)) {
                //设置当前线程以独占的方式持有锁
                this.setExclusiveOwnerThread(current);
                //返回加锁成功
                return true;
            }
          //如果c不等于0，表示锁此时被占着
          //如果当前线程就是锁的持有者
        } else if (current == this.getExclusiveOwnerThread()) {
            //发生重进入，增加重进入的次数
            int nextc = c + acquires;
            //如果nextc小于0即发生了int类型的溢出
            if (nextc < 0) {
                throw new Error("Maximum lock count exceeded");
            }
            //设置state状态
            this.setState(nextc);
            //返回重入加锁成功
            return true;
        }
        //返回加锁失败
        return false;
    }
    //对类AQS的tryRelease()做重写
    @ReservedStackAccess
    protected final boolean tryRelease(int releases) {
        //获取state状态，减去要释放的资源数release
        int c = this.getState() - releases;
        //如果当前线程不是锁的拥有者
        if (Thread.currentThread() != this.getExclusiveOwnerThread()) {
            //抛出异常
            throw new IllegalMonitorStateException();
        } else {
            //是否完全释放锁
            boolean free = false;
            //如果c等于0
            if (c == 0) {
                //表示锁已经完全释放，没有任何线程持有锁
                free = true;
                //将锁的持有者置为null
                this.setExclusiveOwnerThread((Thread)null);
            }
            //设置state状态
            this.setState(c);
            //返回锁是否完全被释放的状态
            return free;
        }
    }
    //对AQS中的isHeldExclusively做重写，检验当前线程是否为锁的拥有者
    protected final boolean isHeldExclusively() {
        return this.getExclusiveOwnerThread() == Thread.currentThread();
    }
    //返回一个AQS内部类ConditionObject对象
    final ConditionObject newCondition() {
        return new ConditionObject(this);
    }
    //返回锁的持有者
    final Thread getOwner() {
        //如果state为0，则未加锁，返回null
        //否则调用getExclusiveOwnerThread方法获取持有者
        return this.getState() == 0 ? null : this.getExclusiveOwnerThread();
    }
    //返回重入锁重进入次数
    final int getHoldCount() {
        //如果isHeldExclusively为true
        //则说明当前线程是锁的持有者，返回state
        //否则返回0
        return this.isHeldExclusively() ? this.getState() : 0;
    }
    //判断是否已经被加锁
    final boolean isLocked() {
        return this.getState() != 0;
    }
    //通过流反序列化对象
    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        this.setState(0);
    }
}

内部类FairSync源码解析

/**
*FairSync继承Sync 实现公平锁
*/
static final class FairSync extends ReentrantLock.Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    /**
    *加锁
    */
    final void lock() {
    acquire(1);
}
    /**
    *父类acquire()方法是个模板方法
    *需要调用子类的tryAcquire()实现 
    */
    @ReservedStackAccess
    protected final boolean tryAcquire(int acquires) {
        //当前线程
        Thread current = Thread.currentThread();
        //锁状态
        int c = this.getState();
        //c等于0表示未被锁定
        if (c == 0) {
            //hasQueuedPredecessors()是父类AQS中的方法
            //用于查询是否有等待获取锁的时间比当前线程更长的线程
            //如果没有比当前线程等待更久的线程
            //则通过CAS设置state状态从0变成acquires
            //如果CAS成功，说明线程加锁成功
            //设置锁的持有者为当前线程
            if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, acquires)) {
                this.setExclusiveOwnerThread(current);
                //返回加锁成功
                return true;
            }
          //如果c不等于0
          //判断当前线程是不是锁的拥有者
          //如果是则发生重入
        } else if (current == this.getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0) {
                throw new Error("Maximum lock count exceeded");
            }
            this.setState(nextc);
            return true;
        }
        return false;
    }
}

ReentrantLock属性源码解析

ReentrantLock只有一个属性，就是内部类Sync

private final Sync sync;

ReentrantLock构造器源码解析

/**
 * 默认是非公平锁
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 * 通过参数执行公平/非公平锁
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

ReentrantLock公平锁加锁/解锁源码解析

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

ReentrantLock的lock()方法调用Sync的lock()方法。sync是ReentrantLock的属性，从ReentrantLock的构造器可以看出，sync可能是公平锁或非公平锁。

ReentrantLock公平锁加锁源码解析

进入FairSync的lock()方法

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

调用父类AQS的acquire()方法

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

父类AQS的acquire()方法调用tryAcquire()方法，由子类实现

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

tryAcquire()方法在FairSync的实现如下：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    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;
}

如果tryAcquire()方法返回false，则加锁失败，回到父类AQS的acquire()方法接着执行下面代码

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

先执行addWaiter()方法：

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}

首先以当前线程创建了一个新的节点，将节点尝试通过CAS操作加入到同步队列的末尾，如果CAS失败，则存在竞争队尾的情况，调用enq()方法进行自旋：

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;
            }
        }
    }
}

回到父类AQS的acquire()方法，addWaiter()执行结束，将会执行acquireQueued()：

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取当前节点的前驱节点
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                //设置当前节点为头节点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                //正常情况下循环唯一的出口
                return interrupted;
            }
            //判断是否要阻塞当前线程
            if (shouldParkAfterFailedAcquire(p, node) &&
                //阻塞当前线程
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }

当前线程首先判断前驱节点是否是头节点。如果是则尝试获取锁，获取锁成功则会设置当前节点为头节点。如果当前节点的前驱节点不是头节点，或者尝试加锁失败，调用shouldParkAfterFailedAcquire()方法，确保前驱节点为SIGNAL，然后阻塞当前线程：

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;
}

根据前驱节点的不同状态进行不同操作：

  1. pred的状态为SIGNAL，直接返回true，表示要阻塞当前线程
  2. pred的状态为CANCELLED，则一直向前回溯直到找到第一个状态不为CANCELLED的节点，将当前节点node挂在这个节点后面
  3. pred的状态为初始化状态，通过CAS操作，把pred的状态改为SIGNAL

其实这个方法很简单，就是确保了前驱节点为SIGNAL状态，只有这样才意味着线程释放锁后会唤醒后面的阻塞线程，只有在确保了会被唤醒的情况下，当前线程才能放心被阻塞。
shouldParkAfterFailedAcquire返回true，应当阻塞当前线程，则接着执行方法parkAndCheckInterrupt()，此方法调用了LockSupport来阻塞线程

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

ReentrantLock公平锁解锁源码解析

ReentrantLock解锁源码如下：

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

调用父类AQS的release()方法：

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

tryRelease()方法由子类实现：

protected boolean tryRelease(int arg) {
    throw new UnsupportedOperationException();
}

tryRelease()方法在ReentrantLock中的Sync中实现：

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;
}

tryRelease()方法返回true，即解锁成功。将会执行unparkSuccessor()方法唤醒后继节点：

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;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

ReentrantLock非公平锁加锁/解锁源码解析

ReentrantLock非公平锁加锁源码解析

非公平锁加锁入口与公平锁加锁一样，都是lock()方法，只是调用的sync对象的引用不同：

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

NonfairSync中lock()方法的实现如下：

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

与公平锁FairSync中的lock()方法不同，NonfairSync中对lock()方法直接进行CAS操作。成功则设置当前线程为锁的持有者。CAS操作失败，说明存在竞争，进入父类AQS的acquire()方法：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

tryAcquire()方法依旧需要子类实现。NonfairSync中的实现如下：

protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}

NonfairSync中tryAcquire()方法调用的是nonfairTryAcquire()是父类Snyc的方法：

 final boolean nonfairTryAcquire(int acquires) {
        //当前线程
        Thread current = Thread.currentThread();
        //获取锁的状态，即AQS中的state状态
        int c = this.getState();
        //c == 0表示没有线程持有该锁
        if (c == 0) {
            //CAS修改state状态，如果CAS成功，即加锁成功
            if (this.compareAndSetState(0, acquires)) {
                //设置当前线程以独占的方式持有锁
                this.setExclusiveOwnerThread(current);
                //返回加锁成功
                return true;
            }
          //如果c不等于0，表示锁此时被占着
          //如果当前线程就是锁的持有者
        } else if (current == this.getExclusiveOwnerThread()) {
            //发生重进入，增加重进入的次数
            int nextc = c + acquires;
            //如果nextc小于0即发生了int类型的溢出
            if (nextc < 0) {
                throw new Error("Maximum lock count exceeded");
            }
            //设置state状态
            this.setState(nextc);
            //返回重入加锁成功
            return true;
        }
        //返回加锁失败
        return false;
    }

与非公平锁加锁不同，公平锁加锁调用了hasQueuedPredecessors()方法，判断等待队列中是否存在比当前线程先入队的线程。公平锁需要对先入队的线程进行让步，先来后到。非公平锁不管先来后到，直接加锁。
tryAcquire()方法返回false，则加锁失败。将继续执行：

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

随后的流程跟公平锁一致。

ReentrantLock非公平锁解锁源码解析

ReentrantLock非公平锁解锁与公平锁解锁过程一样。

公平锁FairSync VS 非公平锁NonfairSync

两者没有绝对的好坏之分，根据具体的场景选择对应的锁技术才是好的。

  • 公平锁——侧重公平性，先来后到。
  • 非公平锁——侧重并发性，调用即加锁。

非公平锁对锁的竞争是抢占式的（队列中的线程除外），线程在进入等待队列前可以进行两次尝试，很大程度上增加了获取到锁的机会。优点在于：

  1. 线程不必加入等待队列就可以获得锁，不仅免去了构建节点并加入队列的繁琐操作，同时也节省了线程阻塞唤醒的开销。线程阻塞和唤醒涉及到线程上下文的切换和操作系统的系统调用，是非常耗时的。在高并发情况下，如果线程持有锁的时间非常短，短到线程入队列阻塞的过程超过线程持有锁并释放锁的时间开销，那么这种抢占式的特性对并发性能的提升会更加明显
  2. 减少CAS竞争。如果线程必须要加入阻塞队列才能获取到锁，那入队时CAS竞争将变得异常激烈，CAS操作虽然不会导致失败的线程挂起，但是不断失败重试导致对CPU的浪费也不能忽视。
努力的小强
关注
专栏目录
ReentrantLock源码解析（二）
12-21
《ReentrantLock源码解析（二）》 在Java并发编程中，ReentrantLock是一个重要的同步工具类，它提供了一种比synchronized更细粒度的锁控制机制。本文主要探讨ReentrantLock的内部实现，特别是其数据结构和关键方法...
并发编程基础ReentrantLock源码分析
北洋的博客
02-16 2908
//Note1:（双向链表。初始的时候head和tail都指向Null，之后添加新节点的时候会创建一个空Node，head和tail都指向这个空Node代表初始化完成。尾插法入队通过移动尾结点tail往前移动,出队通过移动head节点head节点往前移动。当Head节点和tail指向同一个Node时代表没有阻塞队列中没有等待的线程） //之后唤醒的时候也会通过tail尾结点一直像后遍历拿到真正处于等待状态的Node线程，然后通过LockSupport提供的Unpark指定唤醒Node线程； // 阻塞的时候
ReentrantLock源码分析
最新发布
weixin_45102820的博客
08-05 778
不可打断是指当前线程被打断了，但是他还需要去获取锁，如果获取锁失败，继续park，获取锁成功就返回true，然后将当前线程打断标记设为true。2、将该节点从等待队列断开，并加入AQS队列尾部进行等待，如果成功就直接退出，如果失败就循环唤醒下一个节点。当前线程尝试获取锁时，会先判断AQS队列中是否有线程，如果有，就获取锁失败，否则才去获取锁。方法获取锁是可以被打断的，当线程在AQS队列等待时被打断，会直接抛出异常，然后退出。3、将AQS队列中原来的尾结点状态修改为-1，当前节点作为尾结点，状态为0。
ReentrantLock 源码解析
weixin_45278293的博客
04-24 1011
ReentrantLock 实现了 Lock 接口，内部基于 AQS 实现。所以想要弄懂 ReentrantLock ，一定要先弄明白AQS。ReentrantLock 是可重入锁，同一个线程能够多次获取到同一个 ReentrantLock 锁。ReentrantLock 类采用的是 AQS 技术中的独占模式，实现了 AQS 的 3 个关键方法：tryAcquire（），tryRelease（），isHeldExclusively（）方法。
ReentrantLock的源码分析
雅俗共赏的博客
01-19 543
ReentrantLock的公平锁和非公平锁的具体实现及其区别
第六章 ReentrantLock源码解析2--释放锁unlock()1
08-04
ReentrantLock源码解析之释放锁unlock() ReentrantLock是一个可重入锁，它提供了一个unlock()方法来释放锁。在本章中，我们将深入探讨unlock()方法的源码，了解其释放锁的步骤和机制。 unlock()方法的主要作用是...
第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()1
08-04
本篇文章将深入解析ReentrantLock的源码，重点讨论非公平锁和公平锁的获取过程。 1. **ReentrantLock的基本概念** ReentrantLock是由Java提供的可重入互斥锁，支持公平锁和非公平锁两种模式。非公平锁的特性是获取...
ReentrantLock源码详解--条件锁
08-25
ReentrantLock源码详解--条件锁 ReentrantLock源码详解中最重要的一个部分就是条件锁，条件锁是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。今天我们来...
Java并发之ReentrantLock类源码解析
08-27
Java并发之ReentrantLock类源码解析 ReentrantLock是Java并发包中的一种同步工具，它可以实现可重入锁的功能。ReentrantLock类的源码分析对理解Java并发机制非常重要。本文将对ReentrantLock类的源码进行详细分析，...
ThreadPoolExecutor源码解析.pdf
11-26
《ThreadPoolExecutor源码解析》 ThreadPoolExecutor是Java并发编程中重要的组件，它是ExecutorService接口的实现，用于管理和调度线程的执行。理解其源码有助于我们更好地控制并发环境下的任务执行，提高系统的...
ReentrantLock解析
08-08
《ReentrantLock深度解析》 在Java并发编程中，ReentrantLock是JDK提供的一个可重入互斥锁，它是java.util.concurrent.locks包下的核心类。与synchronized关键字相比，ReentrantLock提供了更高的灵活性，如尝试加锁...
Java源码解析之可重入锁ReentrantLock
08-26
Java源码解析之可重入锁ReentrantLock ReentrantLock是一个可重入锁，在ConcurrentHashMap中使用了ReentrantLock。它是一个可重入的排他锁，它和synchronized的方法和代码有着相同的行为和语义，但有更多的功能。 ...
Renntrantlock原理（源码解析）
qq_40223516的博客
04-24 1420
Renntrantlock原理（源码） 文章目录前言一、ReentrankLockAQS部分源码二、Reentrantlock原理3.ReentrantLock源码实现3.1核心变量和构造器2.公平与非公平锁实现原理总结 前言 记录第一次写博客，在面试中，经常发现会问Synchronized与ReentrantLock的区别，我们知道Synchronized底层是JVM实现的，在字节码中修饰在方法层面的同步关键字，会多一个 ACC_SYNCHRONIZED的判别位，修饰在代码块层面的同步块会多一个 mon
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值