【并发编程】ReentrantLock 源码分析

最新推荐文章于 2024-08-05 00:13:56 发布
最新推荐文章于 2024-08-05 00:13:56 发布
阅读量872 收藏 1
点赞数 1
分类专栏： JDK源码 文章标签： ReentrantLock AQS 重入锁 concurrent Lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhl_jxy/article/details/87088314
版权

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-concurrent）

一 ReentrantLock 概述

ReentrantLock 和 Synchronized 都可以实现同步加锁效果，将并行操作变为串行操作，保证共享资源的线程安全，

ReentrantLock 基于 AQS 实现，通过 lock() 方法获得锁，unlock() 方法释放锁。

二 ReentrantLock 实例

MyService：负责加锁和释放锁。

package com.jpeony.concurrent.locks.reentrantlock.demo1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author yihonglei
 */
public class MyService {
    private ReentrantLock lock = new ReentrantLock();

    public void serviceMethod() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + ", begin ");
        } finally {
            System.out.println(Thread.currentThread().getName() + ", end ");
            lock.unlock();
        }
    }
}

MyThread：负责调用服务方法。

package com.jpeony.concurrent.locks.reentrantlock.demo1;

/**
 * @author yihonglei
 */
public class MyThread extends Thread {
    private MyService service;

    public MyThread(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.serviceMethod();
    }
}

RunTest：测试加锁和释放锁。

package com.jpeony.concurrent.locks.reentrantlock.demo1;

/**
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread t1 = new MyThread(service);
        MyThread t2 = new MyThread(service);
        MyThread t3 = new MyThread(service);
        MyThread t4 = new MyThread(service);
        MyThread t5 = new MyThread(service);

        t1.setName("Thread-A");
        t2.setName("Thread-B");
        t3.setName("Thread-C");
        t4.setName("Thread-D");
        t5.setName("Thread-E");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();

    }
}

运行结果：

从运行结果可以看到，每个线程访问时先调用 lock() 锁定，打印完数据后调用 unlock() 方法释放锁，其他线程才能

获取锁打印信息。打印的数据按线程持有锁分组的，但是线程运行顺序是随机的，也即线程的启动顺序与线程的

运行顺序无关，运行顺序取决于cpu调度。

三 ReentrantLock 源码分析

主要分析 lock() 加锁、unlock() 释放锁。ReentrantLock 加锁和解锁机制，都是基于 AQS 模板方法实现的，

理解 AQS，更容易理解 ReentrantLock 锁机制的本质，AQS 源码分析。

构造器

默认是非公平的加锁方式。

/**
 * 默认是非公平
 */
public ReentrantLock() {
    // 最顶层是 AQS
    sync = new NonfairSync();
}

/**
 * 可以选择公平或非公平 fair：true 公平，false 非公平
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

1、ReentrantLock#lock()

加锁入口。

public void lock() {
    sync.lock();
}
final void lock() {
    // 非公平时，线程先 CAS 尝试获取锁
    if (compareAndSetState(0, 1))
        // 获取锁成功，设置线程为独占锁线程，用于实现线程的重入锁
        setExclusiveOwnerThread(Thread.currentThread());
    else
        // 线程获取锁入口
        acquire(1);
}

非公平锁机制，每次调用当前线程都会去先尝试获取锁，不管锁是否被占用，都要先尝试去获取锁，获取不到了再去排队获取锁，

而公平锁是发现有锁，就老老实实去排队获取锁。 

ReentrantLock#acquire()

尝试获取锁，失败则加入等待队列并挂起线程，等待唤醒获取锁。 

public final void acquire(int arg) {
    // 尝试获取锁，获取失败则进入等待队列
    if (!tryAcquire(arg) &&
        // addWaiter 构建独占模式节点入队，acquireQueued() 尝试获取锁，没有获取到则挂起线程，并进入等待队列
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 线程是否已中断判断
        selfInterrupt();
}

ReentrantLock#tryAcquire() 

尝试获取锁，默认走非公平锁的实现。

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

Sync#nonfairTryAcquire()

1）如果 state 是 0，表示锁未被线程持有，尝试去获取锁，通过 CAS 轻量级操作将 state 变为1，

如果成功，则获取锁成功，否则获取锁失败；

2）如果 state 不是 0，判断是否是当前线程来获取锁，是则是重入锁，只要重入的次数未超过 int 最大值，

即可重入获取成功，如果不是当前线程，则获取锁失败；Lock 锁的重入是通过独占线程变量引用判断，

Synchronized 的重入是通过对象头偏向线程 id 判断实现。

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    // 如果锁未被持有，则尝试去获取锁
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 如果是同一个线程再次获取锁，设置锁状态增加1，返回获取锁成功
    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;
}

AbstractQueuedSynchronizer#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;
    // 尝试快速添加到队列，第一次tail是空，会走enq逻辑
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 初始化队列并将当前节点添加到队尾
    enq(node);
    return node;
}

AbstractQueuedSynchronizer#enq()

初始化队列，当前线程构建的独占节点入队尾。AQS 的队列基于双向链表实现，头结点永远不存放值，

即基于哨兵结点方式简化的带头链表实现队列方式。

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

AbstractQueuedSynchronizer#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;
            }
            // shouldParkAfterFailedAcquire 第一次循环，将会修改节点状态为待唤醒， 
            // parkAndCheckInterrupt 第二次循环，LockSupport.park()暂停线程，程序计数器会标记在这个地方，当线程被唤醒后，线程将会从这个字节码地址继续执行线程，去尝试获取锁。
    // 在unlock() 释放锁的时候，会唤醒等待队列头结点线程尝试获取锁。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

 2、ReentrantLock#unlock()

释放锁。

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

AbstractQueuedSynchronizer#release()

释放锁逻辑。尝试去释放锁，唤醒头结点线程尝试获取锁。

public final boolean release(int arg) {
    // 尝试释放锁
    if (tryRelease(arg)) {
        // 释放锁成功，唤醒头结点的后续节点线程，头结点上是永远没有阻塞线程的，只有对待唤醒线程的next引用。
        Node h = head;
        // 节点不为空，节点状态不是初始状态
        if (h != null && h.waitStatus != 0)
            // 唤醒线程
            unparkSuccessor(h);
        return true;
    }
    return false;
}

ReentrantLock.Sync#tryRelease()

释放状态值。

protected final boolean tryRelease(int releases) {
    // state - 1
    int c = getState() - releases;
    // 独占锁的线程不是当前线程，不允许释放锁，哪个线程加的锁，由哪个线程释放。
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 如果c为0，则释放锁成功，设置独占变量exclusiveOwnerThread为null
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

AbstractQueuedSynchronizer#unparkSuccessor()

唤醒线程，被唤醒的线程尝试获取锁。

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        // 恢复头节点的等待状态为初始值0
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    // 如果节点为空或者是已被取消，迭代找到下一个符合唤醒的节点线程
    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 类与 Condition 类配合实现等待/通知机制

关键字 synchronized 与 wait() 和 notify() 或 notifyAll() 结合可以实现等待/通知机制。而 ReentrantLock 和 Condition 配合

也可以实现等待/通知机制。使用 notify() 和 notifyAll() 无法选择性的通知线程。使用 Condition 的优点就是可以在 Lock

对象里面创建多个 Condition (对象监视器)实例，线程对象可以注册在指定的 Condition 中，从而实现有选择性地进行

线程通知，使线程调度更加的灵活。

Condition类方法:

await()：使线程等待相当于Object对象中的wait()方法。

await(long time, TimeUnit unit)：相当于Object对象中的wait(long timeout)方法。

signal()：通知单个线程相当于Object对象中的notify()方法。

signalAll()：通知所有线程相当于Object对象中的notifyAll()方法。

单个Condition实现等待/通知机制实例:

Service服务类:

package com.jpeony.concurrent.locks.reentrantlock.demo2;


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

/**
 * @author yihonglei
 */
public class MyService {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    /**
     * 等待
     */
    public void await() {
        try {
            lock.lock();
            System.out.println("await time:" + System.currentTimeMillis());
            condition.await(); // 使线程处于等待状态
        } catch (InterruptedException ex) {// 线程中断异常
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 通知
     */
    public void signal() {
        try {
            lock.lock();
            System.out.println("signal time:" + System.currentTimeMillis());
            condition.signal();// 通知等待线程进行唤醒
        } catch (IllegalMonitorStateException ex) {// 监视器不合法异常
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

线程:

package com.jpeony.concurrent.locks.reentrantlock.demo2;

/**
 * @author yihonglei
 */
public class MyThread extends Thread {
    private MyService service;

    public MyThread(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.await();
    }
}

测试类:

package com.jpeony.concurrent.locks.reentrantlock.demo2;

/**
 * 关键字synchronized与wait()合notify()或notifyAll()结合可以实现等待/通知机制。
 * 而ReentrantLock和Condition配合也可以实现等待/通知机制。
 * <p>
 * 使用notify()和notifyAll()无法选择性的通知线程。
 * 使用Condition的优点就是可以在Lock对象里面创建多个Condition(对象监视器)实例，
 * 线程对象可以注册在指定的Condition中，从而实现有选择性地进行线程通知，使线程调度更加的灵活。
 * <p>
 * Condition类中常用方法:
 * await() 使线程等待相当于Object对象中的wait()方法
 * await(long time, TimeUnit unit)相当于Object对象中的wait(long timeout)方法
 * signal() 通知单个线程相当于Object对象中的notify()方法
 * signalAll() 通知所有线程相当于Object对象中的notifyAll()方法
 *
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        try {
            MyService service = new MyService();
            MyThread myThread = new MyThread(service);
            /*
             * 线程启动后执行run方法，调用MyService中的await()方法，
             * 使得线程处于等待状态
             */
            myThread.start();

            // 当前线程(main线程)休眠5秒后往下执行
            Thread.sleep(5000);

            /*
             * 调用signal方法，通知MyService中Condition(监视器)中注册的线程
             * 进行唤醒执行
             */
            service.signal();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

测试结果:

将运行结果signal time与await time做差，结果为5000毫秒左右，因为调用过程耗了点，

正好为RunTest类中Thread.sleep(5000)的5000毫秒，实现了等待/通知机制。

五 多个 Condition 通知部分线程

上面实例分析了线程指定单个Condition实现等待/通知机制，但是，当多个线程多个Condition时，如何实现通知部分线程?

创建Service类:

package com.jpeony.concurrent.locks.reentrantlock.demo3;


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

/**
 * @author yihonglei
 */
public class MyService {
    private Lock lock = new ReentrantLock();

    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    /**
     * A等待
     */
    public void awaitA() {
        try {
            lock.lock();
            System.out.println("waitA begin time: " + System.currentTimeMillis());
            conditionA.await();// 等待
            System.out.println("waitA end time: " + System.currentTimeMillis());
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * B等待
     */
    public void awaitB() {
        try {
            lock.lock();
            System.out.println("waitB begin time: " + System.currentTimeMillis());
            conditionB.await();// 等待
            System.out.println("waitB end time: " + System.currentTimeMillis());
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * conditionA通知:
     * signal() 通知单个线程
     * signalAll() 通知所有线程
     */
    public void signalAll_A() {
        try {
            lock.lock();
            System.out.println("signalAll_A begin time: " + System.currentTimeMillis()
                    + ", ThreadName = " + Thread.currentThread().getName());
            // 通知conditionA监视器中所有处于等待的线程进行唤醒
            conditionA.signalAll();
        } catch (IllegalMonitorStateException ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * conditionB通知:
     * signal() 通知单个线程
     * signalAll() 通知所有线程
     */
    public void signalAll_B() {
        try {
            lock.lock();
            System.out.println("signalAll_B begin time: " + System.currentTimeMillis()
                    + ", ThreadName = " + Thread.currentThread().getName());
            // 通知conditionB监视器中所有处于等待的线程进行唤醒
            conditionB.signalAll();
        } catch (IllegalMonitorStateException ex) {
            ex.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

线程A：

package com.jpeony.concurrent.locks.reentrantlock.demo3;

/**
 * @author yihonglei
 */
public class ThreadA extends Thread {
    private MyService service;

    public ThreadA(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitA();
    }
}

线程B：

package com.jpeony.concurrent.locks.reentrantlock.demo3;

/**
 * @author yihonglei
 */
public class ThreadB extends Thread {
    private MyService service;

    public ThreadB(MyService service) {
        super();
        this.service = service;
    }

    @Override
    public void run() {
        service.awaitB();
    }
}

测试类:

package com.jpeony.concurrent.locks.reentrantlock.demo3;

/**
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        try {
            MyService service = new MyService();
            ThreadA threadA = new ThreadA(service);
            threadA.setName("AAAAA");
            threadA.start();

            ThreadB threadB = new ThreadB(service);
            threadB.setName("BBBBB");
            threadB.start();

            // main线程休眠5秒，才执行后面的代码
            Thread.sleep(5000);
            /*
             * 线程休眠5秒后开始执行service.signalAll_A(),
             * 单纯就是唤醒ThreadA线程，不唤醒ThreadB线程，
             * 这么测试的目的，就是想验证Condition能否做到只唤醒部分线程
             */
            service.signalAll_A();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果:

从运行结果可以看出，A经历了等待--唤醒--唤醒后执行，而B一直处于等待状态，未被唤醒。

线程注册时指定Condition，唤醒时根据Condition唤醒对应注册的线程，从而达到部分通知的能力。

六 总结

1）ReentrantLock 能实现 Synchronized 一样的同步效果，通过 lock() 加锁，unlock() 解锁。

2）ReentrantLock 依赖特殊的 cpu 指令，手动加锁和解锁实现同步效果。

3）ReentrantLock 的 Condition 可以实现等待/通知模式（生产/消费者模型），线程注册到 Condition，

通过 await() 方法等待，通过 signal() 或 signalAll() 实现通知。

4）Synchronized 是 JVM 层面的锁机制，依赖 JVM 底层实现加锁和解锁，底层也是类似 AQS 实现方式，

ReentrantLock 相对更灵活些，比如自己可以控制获取锁的超时时间等，还针对读多写少并发场景基于 AQS 实现了

ReentrantReadWriteLock（读写锁），这些特性都是 synchronized 没有的，但是 synchronized 使用更简单，

完全依赖 JVM 内部机制，代码更加简洁。

街灯下的小草
关注
专栏目录
ReentrantLock的实现原理
盛夏温暖流年
09-30 4384
ReentrantLock 简介 ReentrantLock 实现了 Lock 接口，是一种可重入的独占锁。 相比于 synchronized 同步锁，ReentrantLock 更加灵活，拥有更加强大的功能，比如可以实现公平锁机制。 首先，先来了解一下什么是公平锁机制。 ReentrantLock 的公平锁机制 我们知道，ReentrantLock 分为公平锁和非公平锁，可以通过构造方法来指定具体类型： //默认非公平锁 public ReentrantLock() { sync =
并发源码解析（四）--ReentrantLock
Double____C的博客
10-17 189
一、ReentrantLock ReentrantLock是可重入的独立锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞而被加入该锁的AQS阻塞队列里面。 可以实现公平锁和非公平锁 二、源码分析 2.1 继承关系 实现了lock接口和序列化接口 还有3个静态内部类 其中的关系如下： 其中Sync的lock方法为抽象方法，交给子类去实现 2.2 构造方法 无参构造方法 publ...
ReentrantLock实现原理
weixin_30687587的博客
02-15 404
以下是本篇文章的大纲 1 synchronized和lock 1.1synchronized的局限性 1.2 Lock简介 2 AQS 3 lock()与unlock()实现原理 3.1 基础知识 3.2 内部结构 3.3 NonfairSync 3.3.1 lock() 3.3.2 unlock() 3.3.3 小结 3.4 FairS...
ReentrantLock源码分析
最新发布
weixin_45102820的博客
08-05 763
不可打断是指当前线程被打断了，但是他还需要去获取锁，如果获取锁失败，继续park，获取锁成功就返回true，然后将当前线程打断标记设为true。2、将该节点从等待队列断开，并加入AQS队列尾部进行等待，如果成功就直接退出，如果失败就循环唤醒下一个节点。当前线程尝试获取锁时，会先判断AQS队列中是否有线程，如果有，就获取锁失败，否则才去获取锁。方法获取锁是可以被打断的，当线程在AQS队列等待时被打断，会直接抛出异常，然后退出。3、将AQS队列中原来的尾结点状态修改为-1，当前节点作为尾结点，状态为0。
ReentrantLock源码分析(AQS)
chy_want的博客
04-27 287
1.结构 ReentrantLock 类内定义了抽象类Sync，以及实现抽象类的NonfairSync和FairSync，重写了lock和tryAcquire(非公平锁直接去调用了抽象类实现的)方法。 Sync 这边我们可以看到Sync是基于AbstractQueuedSynchronizer实现的。 abstract static class Sync extends AbstractQueuedSynchronizer { private static final long serialV
ReentrantLock 源码简单分析
qq_34183085的博客
02-22 215
ReentrantLock 源码简单分析 大部分内容来自转载https://www.cnblogs.com/waterystone/p/4920797.html，我只写了state和Condition部分， 作者：水岩 出处：http://www.cnblogs.com/waterystone 本博客中未标明转载的文章归作者水岩和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。 只简单分析非公平锁的实现
ReentrantLock源码分析（一）
qq_36500178的博客
06-11 287
1.ReentrantLock简介 理解了AQS，ReentrantLock理解起来其实就没有什么难度了。ReentrantLock，可重入锁。它可以等同于 synchronized的使用，但是ReentrantLock提供了比synchronized更强大、灵活的锁机制，可以减少死锁发 生的概率。 2.ReentrantLock继承关系 Lock中的方法： 主要提供了获取锁、尝试获取锁、释放锁、条件锁等几个方法。 3.源码分析 3.1 ReentrantLock内部类 ReentrantLock内部
7、深入理解AQS独占锁之ReentrantLock源码分析(1).pdf
02-28
### 三、ReentrantLock源码分析 #### 3.1 ReentrantLock介绍 ReentrantLock是一种基于AQS框架实现的可重入锁。它可以显式地控制锁的获取和释放，并提供了公平性和非公平性两种获取策略。此外，ReentrantLock还支持...
java并发编程源码分析-javaThread:java并发编程实战手册源码分析
05-24
`javaThread`项目则是一个专门针对Java并发编程进行源码分析的实战手册，它旨在帮助开发者深入理解Java线程的内部机制和并发工具的实现原理。 在Java中，`Thread`类是所有线程的基础，它是Java并发模型的核心。`...
ReentrantLock源码解析
weixin_48288539的博客
10-27 725
解析了ReentrantLock类的部分重点源码。
Java并发编程之AQS ReentrantLock源码及使用分析
qq_40239169的博客
06-30 472
Java并发编程之AQS ReentrantLock源码及使用分析
java并发锁ReentrantLock源码分析一 可重入支持中断锁的实现原理
m0_64383736的博客
12-10 409
问题1：一个线程用lock方法申请锁而被阻塞后，调用线程的interput方法，会发生什么情况，能中断锁的获取吗？ 问题2：什么是CLH算法，RenntrantLock针对CLH算法做了哪些变化。 问题3：Node.CANCEL状态的节点在什么时候会删除。 1、ReentrantLock#lock 方法详解 ========================= 如下摘录自  ReentrantLock.NonFairSync final void lock() { if (compareAndSet
ReentrantLock源码简单分析
之城的专栏
05-11 3435
ReentrantLock 能用于更精细化的加锁的Java类, 通过它能更清楚了解Java的锁机制 ReentrantLock 类的集成关系有点复杂, 既有内部类, 还有多重继承关系
ReentrantLock的源码分析
QXF1122的博客
03-16 140
J.U.C简介 Java.util.concurrent 是在并发编程中比较常用的工具类，里面包含很多用来在并发 场景中使用的组件。比如线程池、阻塞队列、计时器、同步器、并发集合等等。并发包的作者是大名鼎鼎的 Doug Lea。我们在接下来的课程中，会去剖析一些经典的比较常用的组件的设计思想。 LOCK Lock 在 J.U.C 中是最核心的组件，前面我们讲synchronized的时候说过，锁最重要的特性就是解决并发安全问题。为什么要以 Lock 作为切入点呢？如果有同学看过 J.U.C 包中的所有组件，
ReentrantLock 源码分析
等风
02-14 480
ReentrantLock 源码分析简介Lock接口提供的功能公平锁和非公平锁公平锁非公平锁公平锁和非公平锁性能对比 简介 ReentrantLock是Java SE 5新增的jdk层面实现可重入锁的功能， 提供了与synchronized类似的同步功能，只是在使用时需要显示的获取和释放锁。虽然缺少了隐私获取和释放锁的便捷性，但是缺拥有了锁获取和释放的可操作性、可中断的获取锁以及超时获取锁等多种s...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值