Java多线程（二）—— ReentrantLock 源码分析

于 2023-02-10 12:00:21 发布
阅读量181 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/128967717
版权

ReentrantLock源码解析

ReentrantLock 是可重入的互斥锁，虽然具有与 Synchronized 相同的功能，但比 Synchronized 更加灵活。 ReentrantLock 底层基于 AQS（AbstractQueuedSynchronizer）实现。

Reentrant 实现了 Lock 接口，其是 Java 对锁操作行为的统一规范，Lock接口定义如下:

public interface Lock{
    //获取锁
    void lock();
    //获取锁-可以响应中断
    void lockInterruptibly() throws InterruptedException;
    //尝试获取一次锁
    boolean tryLock();
    //返回获取锁是否成功状态 - 响应中断
    boolean tryLock(long time,TimeUnit unit) throws InterrptedException;
    //释放锁
    void unlock();
    //创建条件变量
    Condition newCondition();
}
复制代码

1. ReentrantLock的使用

使用 ReentrantLock 的 lock() 方法进行锁的获取，即上锁。使用 unlock() 方法进行解锁。

public class ReentrantLockDemo1 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try{
			//临界区代码
        }finally {
            //为避免临界区代码出现异常，导致锁无法释放，必须在finally中加上释放锁的语句
            lock.unlock();
        }
    }
}
复制代码

ReentrantLock 也是可重入锁：

public class ReentrantLockDemo1 {
    ReentrantLock lock = new ReentrantLock();

    Thread t1 = new Thread() {
        @Override
        public void run() {
            lock.lock();
            try {
                //获取锁之后，在m1中进行锁的重入
                m1();
            } finally {
                lock.unlock();
            }
        }

        private void m1() {
            lock.lock();
            try {
                //临界区
            } finally {
                lock.unlock();
            }
        }
    };

    public static void main(String[] args) {
        ReentrantLockDemo1 demo = new ReentrantLockDemo1();
        demo.t1.start();
    }

}

复制代码

默认情况下，通过构造方法new ReentrantLock()获取的锁为非公平锁。

public class ReentrantLock{
    ...
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
	...
}
复制代码

为观察公平与非公平的区别，我们尝试如下程序：

public class ReentrantLockDemo1 {
    //启用公平锁
    ReentrantLock lock = new ReentrantLock(true);

    Runnable run = new Runnable() {
        @Override
        public void run() {
            for (int i = 100; i > 0; i--) {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " got the lock");
                } finally {
                    lock.unlock();
                }
            }
        }
    };

    public static void main(String[] args) {
        ReentrantLockDemo1 demo = new ReentrantLockDemo1();
        Thread t1 = new Thread(demo.run,"t1");
        Thread t2 = new Thread(demo.run,"t2");
        t1.start();
        t2.start();
    }

}
复制代码

使用公平锁时，上述程序运行结果：

t1 got the lock
t2 got the lock
t1 got the lock
t2 got the lock
t1 got the lock
t2 got the lock
t1 got the lock
...
复制代码
  1. t1获取到锁的时候，t2发现有人持有锁，进入队列中排队
  2. t1释放锁的时候，唤醒t2，t2程序继续运行
  3. t1开始acquire()方法，而t2已经在判断自己是否为队列头，并尝试获取锁
  4. 正常情况t2会比t1更先获取到锁资源
  5. t1发现t2持有锁，t1进入队列中排队
  6. 循环上述情况导致运行结果如上。

使用非公平锁时，上述程序运行结果：

...
t1 got the lock
t1 got the lock
t1 got the lock
t1 got the lock
t2 got the lock
t2 got the lock
t2 got the lock
...
复制代码
  1. t1获取锁的时候，t2在队列中排队
  2. t1释放锁的时候，唤醒t2，t2程序继续运行
  3. t2还在尝试获取前驱，并tryAquire()时，t1已经在casState()了
  4. 正常情况t1会比t2更快获取到所资源
  5. t2发现t1有锁，t2进入队列中排队
  6. 循环上述情况导致运行结果如上。

2. ReentrantLock的实现方式

2.1 非公平锁与公平锁的上锁实现

step1: lock() —— 上锁入口

ReentrantLock 首先调用 lock 方法尝试获取锁资源。

public void lock() {
    sync.lock();
}
复制代码

开启公平锁时，sync 对象为 FairSync 实例，开启非公平锁时，sync 对象为 NonFairSync 对象。

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
复制代码

观察公平与非公平的 lock() 实现方式的不同。我们发现：

公平锁在获取锁的时候，会直接进行 acquire() ，而非公平锁则是直接尝试 CAS 去更新锁资源的 state 变量，更新成功则获取到锁资源，如果获取不到，才会进入 acquire()。这里涉及到 AQS 的 state 与 双向链表数据结构，可以在AQS专题学习。抽象队列同步器AQS（AQS原理、底层数据结构、Node节点、相关设计模式）

CAS + volatile 实现线程安全地更新变量

CAS（CompareAndSwap）：在Java中，使用Unsafe类的compareAndSet()方法可以通过底层的 lock cmpxchg 指令实现原子性操作。

volatile ：保证了线程间的变量一致性，即可见性。

CAS + Volatile：多线程场景中，某个个线程通过 CAS 将 volatile 修饰的变量更新成功后，所有线程在使用该变量时，都可见该变量的最新值。从而保证，在多线程场景下，对该变量的修改，不会引起线程安全问题。

static final class FairSync extends Sync {
    	...
        final void lock() {
            //直接进入acquire
            acquire(1);
		}
}

static final class NonfairSync extends Sync {
       	...
        final void lock() {
            //先尝试更新AQS的State竞争锁
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //直接获取锁失败时，才会进入acquire
                acquire(1);
        }
}
复制代码

compareAndSetState() ：调用 Unsafe类提供的native层的原子性 CAS 操作。修改 AQS 中的 state 变量。

protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
复制代码

setExclusiveOwnerThread()：在 AQS 中将当前线程设置为锁的持有者

protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
}
复制代码

step2: accquire() —— 模板方法

FairSync 与 NonFairSync 都是 AQS 的子类，acquire() 是 AQS 向子类提供的模板方法。其中 tryAcquire() 方法需要子类重写实现。

public final void acquire(int arg) {
    	//先根据公平与非公平不同的方式，进行尝试获取锁
        if (!tryAcquire(arg) &&
            //如果获取失败，则排队等待
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
}
复制代码

step3: tryAquire() 的不同实现

tryAquire()方法需要子类重写实现，在 AQS 中，该方法仅抛出一个异常：

protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
}
复制代码

先看到公平锁对 tryAquire() 的实现。公平锁的 tryAquire() 主要做了：

  1. 如果自己持有锁，则进行锁的重入
  2. 如果锁空闲，先看是否有人排队（非公平会直接CAS获取锁）
  3. 如果没有人排队，则CAS尝试获取所资源
protected final boolean tryAcquire(int acquires) {
       final Thread current = Thread.currentThread();
       //查看是否有人持有锁
       int c = getState();
       if (c == 0) {//如果没有人持有锁
           //查看是否有人排队，如果没人排队则尝试CAS获取锁
           if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                //获取锁成功，将AQS持有锁的线程设置为本线程
                setExclusiveOwnerThread(current);
                return true;
           }
        }
        else if (current == getExclusiveOwnerThread()) {
            //锁的重入
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            //这里可以直接设置，同一个线程，不会有线程安全。
            //state>0表示有人持有锁，state的具体数值表示锁的重入次数
            setState(nextc);
            return true;
        }
        return false;
}
复制代码

而非公平锁则不同，非公平锁的 tryAquire() 主要做了：

  1. 如果自己持有锁，则进行锁的重入
  2. 如果锁空闲，直接CAS尝试获取锁（公平锁会先看是否有人排队)
final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            //如果锁资源空闲，直接CAS尝试获取锁
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            //锁的重入
            int nextc = c + acquires;
            //重入次数过多，int类型会overflow变成负数
            if (nextc < 0) // overflow
               throw new Error("Maximum lock count exceeded");
            //锁重入，直接设置新的值，不会有线程安全问题
            setState(nextc);
            return true;
        }
        return false;
}
复制代码

step4. 入队并阻塞线程，由 AQS 实现

在acquire()模板方法中，如果tryAquire()没有获取到锁，将会准备在 AQS 中排队。主要工作：

  1. 将当前线程包装在 AQS 的 Node结构 中
  2. 插入 AQS 的双向队列的队尾
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

private Node addWaiter(Node mode) {
    //将要入队的线程封装到 AQS 的 Node结构 中
    Node node = new Node(Thread.currentThread(), mode);
    //获取队尾元素
    Node pred = tail;
    //如果队尾元素不为空，则跟在队尾元素之后
    if (pred != null) {
        node.prev = pred;
        //通过CAS保证线程安全地入队
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
       }
    }
    //如果入队失败，通过enq来循环CAS，自旋尝试入队
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //如果队尾为空，说明队中没有元素，连head都没有
        if (t == null) { // Must initialize
            //cas 使队头队尾指针指向空Node
            //head-> Node() <- tail
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //线程安全地尝试插入队尾
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}
复制代码

通过addWaiter()，不论公平锁还是非公平锁，都将当前线程包装在Node结构中，并插入到 AQS 的双向链表的队列末尾。

而后在 acquireQueued() 中，视情况再次获取锁，或者直接尝试阻塞线程：

  1. 如果该线程所在的Node在队列中处于队头，可以tryAquire()再次尝试获取锁资源，公平锁与非公平锁都将直接 CAS 争取。（因为即使是公平锁，该线程也处在队头，hasQueuedPredecessors()判断为真）
  2. 如果获取失败，将做阻塞前的准备
  3. 阻塞准备完成后阻塞线程。
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //获取前驱节点
                final Node p = node.predecessor();
                //如果前驱是head（head是空节点），说明当前Node排在队头，尝试获取所资源
                if (p == head && tryAcquire(arg)) {
                    //如果获取资源成功，则不阻塞当前线程，而是return回去，继续程序的执行
                    //同时将包装当前的Node清空，并变为新的head
                    setHead(node);
                    //将原来的头清空应用，等待GC回收
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //如果争锁失败，将会准备阻塞，如果本次准备失败，将会再循环一次到这里，准备成功即可阻塞。
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            ...
        }
}
复制代码

shouldParkAfterFailedAcquire() 做了阻塞线程前的判断，主要工作是：

  1. 如果前驱结点是正常的（waitStatus < 0），则当前线程可以阻塞。
  2. 如果前驱结点的waitStatus==0，说明刚被初始化，还没被使用，CAS尝试将其更新为waitStatus = -1；
  3. 如果前驱结点的waitStatus>0，则该前驱结点是要被废弃的，更新链表结构，抛弃废弃的前驱结点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)//waitStatus = -1
            return true;//前驱结点正常，当前线程可以阻塞
        if (ws > 0) {//waitStatus = CANCELLED = 1
            do {//更新前驱节点，将node的前驱引用指向更前一个
                //pred = pred.prev;
                //node.prev = pred;
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //最后将可用的前驱结点指向node自己，从而抛弃中间若干个废弃的节点
            pred.next = node;
        } else {
            //如果node的waitStatus<0 但不是-1，只需要都统一更新为-1即可。
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
}
复制代码

准备工作完成，就可以进入线程阻塞，parkAndCheckInterrupt()方法通过Unsafe类实现线程的阻塞。

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

//LockSupport:
public static void park(Object blocker) {
        Thread t = Thread.currentThread();
    	//设置写屏障 write barrier
        setBlocker(t, blocker);
    	//通过UNSAFE类的park()native方法进行线程的阻塞。
        UNSAFE.park(false, 0L);
    	//设置写屏障 write barrier
        setBlocker(t, null);
}

复制代码

2.2 公平锁与非公平锁的解锁实现

不论是公平锁还是非公平锁，解锁的实现是一致的：

  1. 每次解锁，都对state值减1
  2. 如果state的值变为了0，说明即使重入的锁，也都完全退出
  3. 将 AQS 对持有锁线程的引用置为null
  4. 唤醒等待队列中的某个线程
//ReentrantLock
public void unlock() {
    sync.release(1);
}
//Sync extends AQS
public final boolean release(int arg) {
    //解锁
    if (tryRelease(arg)) {
        Node h = head;
        //如果解锁完成，如果队列中有元素，则唤醒队列中的某个线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

//Sync
protected final boolean tryRelease(int releases) {
    	//计算本次解锁后 state 的值
        int c = getState() - releases;
    	//如果要解锁的不是持有锁的线程，说明程序出了问题
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
    	//如果解锁后的值为 0，说明彻底解锁
        if (c == 0) {
            free = true;
            //去掉 AQS 对持有锁线程的引用
            setExclusiveOwnerThread(null);
        }
    	//设置新的state值
        setState(c);
        return free;
}

复制代码

其中，解锁后需要唤醒队列中的某个线程，主要流程是:

  1. 如果队列中有元素，就会进入 unparkSuccessor() 进行唤醒
  2. 将node的waitStatus值设为0，变为初始化状态
  3. 获取其后继节点
    1. 如果有后继节点，则唤醒该节点
    2. 如果没有后继节点，或者后继节点是废弃的（waitStatus=1），从队尾往前循环找到下一个可用的前驱节点，并唤醒它
      1. 如果全是废弃的，那么什么也不做。
private void unparkSuccessor(Node node) {
    	//获取头结点的waitStatus
        int ws = node.waitStatus;
        if (ws < 0)
            //如果头结点是个被复用的空节点，把它设置为初始化状态，即waitStatus = 0
            compareAndSetWaitStatus(node, ws, 0);
		//获取头结点的后继节点
        Node s = node.next;
    	//如果没有后继节点，或者后继节点废弃
        if (s == null || s.waitStatus > 0) {
            s = null;
            //从队尾往前寻找
            //将会遍历到head为止
            //最后的s将会是head后继中第一个可用的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
    	//如果最后找到一个可用的节点，那么唤醒其绑定的线程
        if (s != null)
            LockSupport.unpark(s.thread);
}
复制代码

之所以解锁要从后往前遍历，是为了确保便利的 node 是在 AQS 队列中的。 在多线程场景下，可能有多个线程同时被包装为 node 结构请求入队，请求入队时，会将队尾元素的 next 指向自己，并cas尝试将自己设置为队尾元素，在CAS成功之前，就已经将tail.next 的指向做了修改！。 试想，如果要从前往后遍历：假设线程 A 需要被阻塞，请求进入 AQS 队列，将 AQS 队列的队尾元素 tail 的 next 指向了自己，但 CAS 还未成功的时候，上述 unparkSuccessor() 方法被调用，从前往后遍历，恰好遍历到线程 A 所在的 node ，且该 node 是一个可用节点（初始waitStatus==0），此时将对线程 A 所在的 node 进行 unpark(), 这显然是不对的。所以为了安全起见，解锁要从后往前遍历，找到距离 head 最近的可用的节点。

至此，ReentrantLock 的加锁与解锁全部分析完成。最后附上非公平锁的加锁时序图：

3.为什么Sync实现nonfairTryAcquire()?

因为 tryLock() 没有公平与非公平的概念，都是走非公平的逻辑，调用sync.nonfaireTryAquire()，即：

  1. 如果锁空闲，则CAS一次，尝试获取锁
  2. 如果锁非空闲，但可重入，则重入
  3. 1和2都失败，则return false。

作者：Tuuu64759
链接：https://juejin.cn/post/7198154204539174949

「已注销」
关注
java中多线程reentlock_Java多线程系列——深入重入锁ReentrantLock
weixin_33646989的博客
02-26 343
简述ReentrantLock 是一个可重入的互斥(/独占)锁，又称为“独占锁”。ReentrantLock通过自定义队列同步器(AQS-AbstractQueuedSychronized，是实现锁的关键)来实现锁的获取与释放。其可以完全替代 synchronized 关键字。JDK 5.0 早期版本，其性能远好于 synchronized，但 JDK 6.0 开始，JDK 对 synchroni...
Java多线程5—ReentrantLock与Condition
clyss1234的博客
09-29 692
文章目录1. ReentrantLock重入锁1.1 ReentrantLock源码解析1.1.1 lock操作1.1.2 release操作2. synchronized和Reetrantlock的区别3. Condition及其介绍3.1 Condition的介绍3.2 Condition在AQS中的使用3.3 Condition在阻塞队列中的实现4. [阻塞和唤醒线程——LockSupport功能简介及原理浅析](https://www.cnblogs.com/takumicx/p/9328459.h
ReentrantLock源码分析
12-26
近日，阅读jdk并发包源码分析整理笔记。
【Java】ReentrantLock源码分析
See_Star的博客
06-30 626
ReentrantLock源码分析
Java并发编程之ReentrantLock源码分析
cherry93925的博客
12-22 247
ReentrantLock介绍 从JDK1.5之前，我们都是使用synchronized关键字来对代码块加锁，在JDK1.5引入了ReentrantLock锁。在JDK1.6之前synchronized关键字性能比ReentrantLock锁要差，JDK1.6之后性能基本是持平，但Reentr...
Java 源码 - ReentrantLock 源码解析
热门推荐
。
09-30 20万+
不啰嗦，我们直接开始！ 引导语 上两小节我们学习了 AQS，本章我们就要来学习一下第一个 AQS 的实现类：ReentrantLock，看看其底层是如何组合 AQS ，实现了自己的那些功能。 本章的描述思路是先描述清楚 ReentrantLock 的构成组件，然后使用加锁和释放锁的方法把这些组件串起来。 1、类注释 ReentrantLock 中文我们习惯叫做可重入互斥锁，可重入的意思是同一个线程可以对同一个共享资源重复的加锁或释放锁，互斥就是 AQS 中的排它锁的意思，只允许一个线程获得锁。
Java ReentrantLock源码分析
Owen的博客
09-27 284
ReentrantLock 是java.util.concurrent.locks下的一个类，主要实现了Synchronized关键字的功能，同时扩展了一些功能，例如 锁投票，定时锁等候和中断锁等候。利用volatile关键字和CAS操作实现。 一、 Lock 接口方法 // 请求锁，直到获取到锁 void lock(); // 获取锁，获取不到就跑异常 void lockInterruptibl...
JDK1.8源码学习篇二——ReentrantLock学习笔记
fyhailin的专栏
04-06 661
一、 引言    上一篇写了AQS的主要方法和原来，也是为学习ReentrantLock做准备的，在一开始的学习的ReentrantLock的锁的时候，发现大部分的方法都是在AQS中，索性干脆就对AQS单独写个学习笔记，有了上面的基础之后，再来看ReentrantLock的源码，应该会简单很多。二、JAVA的锁机制   1. 在jdk的低版本中主要使用Synchronized关键字来获取，这个是一...
死磕 java同步系列之ReentrantLock源码解析（二）——条件锁
彤哥读源码
06-03 271
问题 （1）条件锁是什么？ （2）条件锁适用于什么场景？ （3）条件锁的await()是在其它线程signal()的时候唤醒的吗？ 简介 条件锁，是指在获取锁之后发现当前业务场景自己无法处理，而需要等待某个条件的出现才可以继续处理时使用的一种锁。 比如，在阻塞队列中，当队列中没有元素的时候是无法弹出一个元素的，这时候就需要阻塞在条件notEmpty上，等待其它线程往里面放入一个元素后，唤醒这个条件...
JAVA多线程详解(三)：ReentrantLock实现原理与源码分析
ayugezhoubing的博客
06-28 497
刚学java的多线程通信时，往往只能知道在多线程访问共享资源时加上锁，保证多线程访问共享资源时的同步操作。利用ReentrantLock的lock()方法加锁，利用ReentrantLock的unlock()方法释放锁。那么加锁和释放锁的内部是怎么实现的呢？其源码解释的比较清晰。下面将从源码的整体架构和具体细节来分析ReentraLock的实现原理。由于大量使用了CAS操作，先介绍CAS的实现原理...
java锁ReentrantLock的源码分析
u013510360的专栏
06-08 284
java锁ReentrantLock的源码分析简单的函数介绍加锁过程猜测加锁流程源码分析tryAcquireaddWaiterenqacquireQueued解锁流程tryLock,和lockInterruptibly总结 简单的函数介绍 声明锁对象,构造函数默认不传是创建非公平锁,传true是创建一个公平锁 ReentrantLock lock = new ReentrantLock(true); 重入锁,lock和unlock成对出现, lock.lock(); lock.unlock(); 尝试加
Java 锁系列（三）——ReentrantLock源码分析
玖涯博客
10-18 345
一、ReentrantLock 概述 ReentrantLock 是一个可重入的独占锁，是基于 AQS（AbstractQueuedSynchronized，抽象队列式同步器）实现的，它有公平锁和不公平锁两种实现方式。简单查看源码，可以发现 ReentrantLock 其实是一个代理的模式，Reentranlock 的核心是其内部继承自 AbstractQueuedSynchronized 的抽象类 Sync，将 Sync 作为锁的同步基础，其中加锁/解锁等操作其实都是由 Sync 对象完成的，也是通过实例
ReentrantLock底层源码
Yyuxiansheng的博客
12-02 235
ReentrantLock 概述 ReentrantLock类，实现了LOck接口，是一种可重入的独占锁，它具有与使用synchronized相同的一些基本行为和语义，但功能更强大。 ReentrantLock内部通过内部类实现了AQS框架（AbstractQueuedSynchronized）的API来实现独占锁功能 ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。 先通过CAS尝试获取锁；如果此时已经有线程占据了锁，那就加入AQS队列并且被挂起；当锁被
ReentrantLock底层源码实现
weixin_51749366的博客
11-26 179
ReentrantLock底层源码实现 NonFairSync继承了Sync：尝试立即去加锁，如果锁状态拿到锁之后，调用setExclusiveOwnerThread，哪个线程正在执行，如果没有人持有锁，就换成1，并获知哪个线程持有锁。如果持有到了锁，调用acquire（arg） 锁状态方法（expect、update）：比较并设置状态（AQS底层实现是用CAS），其实是调用CAS过程，比较并设置锁状态——针对当前这个锁对象，加一个锁状态，然后记住哪一个线程加上了锁状态，以后就可以改变这个对象了。如果没加上
java中lock源代码_Java并发系列之ReentrantLock源码分析
weixin_29587015的博客
02-28 119
在Java5.0之前，协调对共享对象的访问可以使用的机制只有synchronized和volatile。我们知道synchronized关键字实现了内置锁，而volatile关键字保证了多线程的内存可见性。在大多数情况下，这些机制都能很好地完成工作，但却无法实现一些更高级的功能，例如，无法中断一个正在等待获取锁的线程，无法实现限定时间的获取锁机制，无法实现非阻塞结构的加锁规则等。而这些更灵活的加锁...
ReentrantLock 细品底层源码
04-08 143
ReentrantLock的基本介绍前言正文常量构造方法 前言 有不少读者都了解过ConcurrentHashMap是一个线程安全的map，其线程安全的原理是其内部类Segment 继承了ReentrantLock，很多读者也止步于此，并未深入了解过ReentrantLock，笔者曾想深入了解一下ConcurrentHashMap，若想了解其并发安全的原理是无法绕过ReentrantLock，所以...
ReentrantLock锁底层源码分析
helloWorld
01-06 473
主要针对lock()、unlock()、锁的可重入性进行源码分析 先来看一个测试代码 public class Test7878 { public static ReentrantLock lock = new ReentrantLock(true); public static void main(String[] args) { Thread t1 = new Thread(()->{ lock.lock();
ReentrantLock底层源码分析
北诗
02-24 202
synchronized关键字的扩展：重入锁（ReentrantLock）: public class ReentrantLock implements Runnable{ public static ReentrantLock lock = new ReentrantLock(); public static int i = 0; public void run(){ ...
Java锁之ReentrantLock（源码详解）
最新发布
小道仙的后宫
01-12 1036
ReentrantLock 这个Java中重要的锁，我想可能很多人只是听过，并没有使用过，我在看RocketMQ客户端源码的时候发现大量的使用了这个ReentrantLock，从而引起了我的兴趣，下面我们一起从源码的角度来学习ReentrantLock。我们先来看一下ReentrantLock的继承关系。
Java多线程深度解析：ReentrantLock互斥锁实战
"Java多线程ReentrantLock互斥锁详解" 在Java多线程编程中，ReentrantLock（可重入锁）是JDK提供的一个高级锁机制，它弥补了synchronized关键字的一些不足，提供了更丰富的锁操作。ReentrantLock在Java并发包`java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值