AQS-ReentrantLock

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量471 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_GIA/article/details/129160033
版权

一、AQS

image.png
在 Lock 中，用到了一个同步队列 AQS，全称 AbstractQueuedSynchronizer，它是一个同步工具，也是 Lock 用来实现线程同步的核心组件。

1.AQS 的两种功能

独占和共享。

  • 独占锁：每次只能有一个线程持有锁，ReentrantLock 就是以独占方式实现的互斥锁。
  • 共享锁 ，允许多个线程同时获取锁 ，并发访问共享资源 ，比如ReentrantReadWriteLock
2.AQS的实现

AQS.png
AQS 队列内部维护的是一个 FIFO 的双向链表，这种结构的特点是每个数据结构都有两个指针，分别指向直接的后继节点和直接前驱节点。所以双向链表可以从任意一个节点开始很方便的访问前驱和后继。
每个 Node 其实是由线程封装，当线程争抢锁失败后会封装成 Node 加入到 AQS 队列中去； 当获取锁的线程释放锁以后，会从队列中唤醒一个阻塞的节点(线程)。

Node组成：

static final class Node {
  
    // 排他锁的标识
    static final Node EXCLUSIVE = null;

    // 如果带有这个标识，证明是失效了
    static final int CANCELLED =  1;
  
    // 具有这个标识，说明后继节点需要被唤醒
    static final int SIGNAL = -1;
   
    // Node对象存储标识的地方
    volatile int waitStatus;

	// 指向上一个节点
    volatile Node prev;

	// 指向下一个节点
    volatile Node next;

    // 当前Node绑定的线程
    volatile Thread thread;

    // 存储在Condition队列中的后继节点
    Node nextWaiter;

  	// 返回前驱节点，如果前驱节点为null，抛出NPE
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    // 将线程构造成一个Node，添加到等待队列
    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
   }

    // 在Condition队列中使用
    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}
3.AQS添加线程

添加节点.png

    1. 新的线程封装成 Node 节点追加到同步队列中，设置 prev 节点以及修改当前节点的前置节点的 next 节点指向自己
    1. 通过 CAS 将 tail 重新指向新的尾部节点
4.AQS释放锁

释放锁.png
head 节点表示获取锁成功的节点，当头结点在释放同步状态时，会唤醒后继节点，如果后继节点获得锁成功，会把自己设置为头结点：

    1. 修改 head 节点指向下一个获得锁的节点
    1. 新的获得锁的节点，将 prev 的指针指向 null

设置 head 节点不需要用 CAS，原因是设置 head 节点是由获得锁的线程来完成的，而同步锁只能由一个线程获得，所以不需要 CAS 保证，只需要把 head 节点设置为原首节点的后继节点，并且断开原 head 节点的 next 引用即可。

二、CAS

1.CAS 的实现原理
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

通过 cas 乐观锁的方式来做比较并替换，如果当前内存中的state 的值和预期值 expect 相等，则替换为 update。更新成功返回 true，否则返回 false。这个操作是原子的，不会出现线程安全问题。

2.state属性

private volatile int state;
state 是 AQS 中的一个属性，它在不同的实现中所表达的含义不一样， 对于重入
锁的实现来说，表示一个同步状态。它有两个含义的表示

  • 当 state=0 时，表示无锁状态
  • 当 state>0 时，表示已经有线程获得了锁，也就是 state=1，但是因为ReentrantLock 允许重入，所以同一个线程多次获得同步锁的时候， state 会递增，比如重入 5 次，那么 state=5。 而在释放锁的时候，同样需要释放 5 次直到 state=0其他线程才有资格获得锁
3.Unsafe类

Unsafe 类是在 sun.misc 包下，不属于 Java 标准。但是很多 Java 的基础类库,包括一些被广泛使用的高性能开发库都是基于 Unsafe 类开发的，比如 Netty、
Hadoop、 Kafka 等；

Unsafe 可认为是 Java 中留下的后门，提供了一些低层次操作，如直接内存访问、线程的挂起和恢复、 CAS、线程同步、内存屏障

而 CAS 就是 Unsafe 类中提供的一个原子操作：
public final native boolean compareAndSwapInt(Object obj, long stateOffset, int expect, int update);

  • obj：需要改变的对象
  • stateOffset：偏移量(即之前求出来的 headOffset 的值)
  • expect：期待的值
  • update：更新后的值

整个方法的作用是如果当前时刻的值等于预期值 expect 相等，则更新为新的期望值 update，如果更新成功，则返回 true，否则返回false；

stateOffset：
一个 Java 对象可以看成是一段内存，每个字段都得按照一定的顺序放在这段内存里，通过这个方法可以准确地告诉你某个字段相对于对象的起始内存地址的字节偏移。用于在后面的 compareAndSwapInt 中，去根据偏移量找到对象在内存中的具体位置
所以 stateOffset 表示 state 这个字段在 AQS 类的内存中相对于该类首地址的偏移量

compareAndSwapInt
unsafe.cpp 文件中compareAndSwarpInt 的实现：

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset,jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt");
oop p = JNIHandles::resolve(obj); //将 Java 对象解析成 JVM 的 oop（普通对象指针） 
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); //根据对象 p 和地址偏移量找到地址
return (jint)(Atomic::cmpxchg(x, addr, e)) == e; //基于 cas 比较并替换， x 表示需要更新的值， addr 表示 state在内存中的地址， e 表示预期值
UNSAFE_END

三、ReentrantLock

ReentrantLock时序图：

ReentrantLock NonfairSync Sync AbstractQueuedSynchronizer lock() lock() acquire() tryAcquire() nonfairTryAcquire() true/false addWaiter() ReentrantLock NonfairSync Sync AbstractQueuedSynchronizer
1.lock()
public void lock() {
	// sync分为了公平和非公平
    sync.lock();
}

sync是一个抽象的静态内部类，它继承了 AQS 来实现重入锁的逻辑。
AQS 是一个同步队列，它能够实现线程的阻塞以及唤醒， 但它并不具备业务功能， 所以在不同的同步场景中，会继承 AQS 来实现对应场景的功能。

Sync 有两个具体的实现类：

  • NofairSync：表示可以存在抢占锁的功能，也就是说不管当前队列上是否存在其他线程等待，新线程都有机会抢占锁
  • FailSync: 表示所有线程严格按照 FIFO 来获取锁

NonfairSync#lock()：

final void lock() {
    // 通过CAS的方式尝试将state从0修改为1，如果返回true，代表修改成功，如果修改失败，返回false
    if (compareAndSetState(0, 1))
        // 将一个属性设置为当前线程，这个属性是AQS的父类提供的
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
  1. 非公平锁和公平锁最大的区别在于，非公平锁中抢占锁的逻辑是，不管有没有线程排队，直接cas去抢占
  2. CAS 成功，就表示成功获得了锁
  3. CAS 失败，调用 acquire(1)走锁竞争逻辑
2.AQS#acquire()

acquire 是 AQS 中的方法，如果 CAS 操作未能成功，说明 state 已经不为 0，此时 acquire(1)操作

public final void acquire(int arg) {
	// tryAcquire再次尝试获取锁资源，如果尝试成功，返回true
    if (!tryAcquire(arg) &&
		// 获取锁资源失败后，需要将当前线程封装成一个Node，追加到AQS的队列中
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		// 线程中断
        selfInterrupt();
}
  • 通过 tryAcquire 尝试获取独占锁，如果成功返回 true，失败返回 false
  • 如果 tryAcquire 失败，则会通过 addWaiter 方法将当前线程封装成 Node 添加到 AQS 队列尾部
  • acquireQueued，将 Node 作为参数，通过自旋去尝试获取锁
3.NonfairSync#tryAcquire()

方法的作用是尝试获取锁，如果成功返回 true，不成功返回 false。
它是重写 AQS 类中的 tryAcquire 方法。

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

final boolean nonfairTryAcquire(int acquires) {
	// 获取当前线程
    final Thread current = Thread.currentThread();
	// 获取AQS的state的值
    int c = getState();
	// 如果state为0，表示无锁状态，尝试再次获取锁资源
    if (c == 0) {
		// CAS尝试修改state，从0-1，如果成功，设置ExclusiveOwnerThread属性为当前线程
        if (compareAndSetState(0, acquires)) {
            // 保存当前获得锁的线程,下次再来的时候不要再尝试竞争锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
	// 当前占有锁资源的线程是否是当前线程
    else if (current == getExclusiveOwnerThread()) {
		// 将state + 1
        int nextc = c + acquires;
		// 如果加1后，小于0，超所锁可重入的最大值，抛出Error
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
		// 没问题，就重新对state进行复制
        setState(nextc);
		// 锁重入成功
        return true;
    }
    return false;
}
4.AQS#addWaiter()

当 tryAcquire 方法获取锁失败以后，则会先调用 addWaiter 将当前线程封装成Node.
入参 mode 表示当前节点的状态，传递的参数是 Node.EXCLUSIVE，表示独占状态。意味着重入锁用到了 AQS 的独占锁功能

  • 1.将当前线程封装成 Node
  • 2.当前链表中的 tail 节点是否为空，如果不为空，则通过 cas 操作把当前线程的node 添加到 AQS 队列
  • 3.如果为空或者 cas 失败，调用 enq 将节点添加到 AQS 队列
// 说明前面获取锁资源失败，放到队列中等待
private Node addWaiter(Node mode) {
	// 创建Node类，并且设置thread为当前线程，设置为排它锁
    Node node = new Node(Thread.currentThread(), mode);
  	// 获取AQS中队列的尾部节点，默认是 null
    Node pred = tail;
	// 如果tail != null，说明队列中存在节点
    if (pred != null) {
		// 把当前线程的 Node 的 prev 指向 tail
        node.prev = pred;
		// 通过 cas 把 node加入到 AQS 队列，也就是设置为 tail
        if (compareAndSetTail(pred, node)) {
			// 设置成功以后，把原 tail 节点的 next指向当前 node
            pred.next = node;
            return node;
        }
    }
	// tail=null,把 node 添加到同步队列
    enq(node);
    return node;
}

// enq ：通过自旋操作把当前节点加入到队列中
// 队列没有节点，我是第一个， 如果前面CAS失败，也会进到这个位置重新往队尾进入。
private Node enq(final Node node) {
	// 死循环
    for (;;) {
		// 重新获取当前的tail节点为t
        Node t = tail;
        if (t == null) { 
			// 队列没有节点, 我是第一个，没头没尾，都是空
            if (compareAndSetHead(new Node()))	// 初始化一个Node作为head，而这个head没有意义。
				// 将头尾都指向了这个初始化的Node
                tail = head;
        } else {
			// 有节点，往队尾入
			// 当前节点的上一个指向tail
            node.prev = t;
			// 基于CAS的方式，将tail节点设置为当前节点
            if (compareAndSetTail(t, node)) {   
				// 将之前的为节点的next，设置为当前节点
                t.next = node;
                return t;
            }
        }
    }
}
5.AQS#acquireQueued()

通过 addWaiter 方法把线程添加到链表后， 会接着把 Node 作为参数传递给acquireQueued 方法，去竞争锁：

  • 1.获取当前节点的 prev 节点
  • 2.如果 prev 节点为 head 节点，那么它就有资格去争抢锁，调用 tryAcquire 抢占锁
  • 3.抢占锁成功以后，把获得锁的节点设置为 head，并且移除原来的初始化 head节点
  • 4.如果获得锁失败，则根据 waitStatus 决定是否需要挂起线程
  • 5.通过 cancelAcquire 取消获得锁的操作
// 已经将node加入到了双向队列中，然后执行当前方法
final boolean acquireQueued(final Node node, int arg) {
	// 标识
    boolean failed = true;
    try {
		// 标识
        boolean interrupted = false;
        for (;;) {
			// 获取当前节点的上一个节点p
            final Node p = node.predecessor();
			// 如果p是头，说明有资格去争抢锁，尝试获取锁资源（state从0-1，锁重入操作），成功返回true，失败返回false
            if (p == head && tryAcquire(arg)) {
				// 获取锁成功，设置head节点为当前节点，将thread，prev设置为null，因为拿到锁资源了 ；
                setHead(node);
                p.next = null;   // 把原 head 节点从链表中移除，帮助GC回收
                failed = false;  // 将标识修改为false
                return interrupted;  // 返回interrupted 
            }
			// 保证上一个节点是-1，才会返回true，才会将线程阻塞，等待唤醒获取锁资源
            if (shouldParkAfterFailedAcquire(p, node) &&
				// 基于Unsafe类的park方法，挂起线程
                parkAndCheckInterrupt();   // 针对fail属性，这里是唯一可能出现异常的地方，JVM内部出现问题时，可以这么理解，fianlly代码块中的内容，执行的几率约等于0
                interrupted = true; // 返回当前线程在等待过程中有没有中断过
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

shouldParkAfterFailedAcquire
如果 ThreadA 的锁还没有释放的情况下， ThreadB 和 ThreadC 来争抢锁肯定是会失败，那么失败以后会调用 shouldParkAfterFailedAcquire 方法
Node 有 5 中状态

  • CANCELLED（1） ：在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该 Node 的结点, 其结点的 waitStatus 为 CANCELLED，即结束状态，进入该状态后的结点将不会再变化
  • SIGNAL（-1） ：只要前置节点释放锁，就会通知标识为 SIGNAL 状态的后续节点的线程
  • CONDITION（-2）
  • PROPAGATE(-3)：享模式下， PROPAGATE 状态的线程处于可运行状态
  • 默认状态（0）
    通过 Node 的状态来判断， ThreadA 竞争锁失败以后是否应该被挂起。
  1. 如果 ThreadA 的 pred 节点状态为 SIGNAL，那就表示可以放心挂起当前线程
  2. 通过循环扫描链表把 CANCELLED 状态的节点移除
  3. 修改 pred 节点的状态为 SIGNAL,返回 false.
    返回 false 时，也就是不需要挂起，返回 true，则需要调用parkAndCheckInterrupt
    挂起当前线程
// node是当前节点，pred是上一个节点
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	// 获取上一个节点的状态
    int ws = pred.waitStatus;
	// 如果上一个节点状态为SIGNAL，意味着只需要等待其他前置节点的线程被释放
    if (ws == Node.SIGNAL)
        return true; // 返回 true，意味着可以直接放心的挂起了
	// ws 大于 0，意味着 prev 节点取消了排队，直接移除这个节点
    if (ws > 0) {
        do {
			// 将当前节点的prev指针指向了上一个的上一个
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);  // 一直找到小于等于0的,从双向列表中移除 CANCELLED 的节点
		// 将重新标识好的最近的有效节点的next
        pred.next = node;
    } else {
		// 小于等于0，不等于-1，将上一个有效节点状态修改为-1
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

parkAndCheckInterrupt:

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

使用 LockSupport.park 挂起当前线程变成 WATING 状态
Thread.interrupted，返回当前线程是否被其他线程触发过中断请求，也就是thread.interrupt(); 如果有触发过中断请求，那么这个方法会返回当前的中断标识true，并且对中断标识进行复位标识已经响应过了中断请求。 如果返回 true，意味着在 acquire 方法中会执行 selfInterrupt()。

selfInterrupt:

static void selfInterrupt() {
    Thread.currentThread().interrupt();
}

标识如果当前线程在 acquireQueued 中被中断过，则需要产生一个中断请求，原因是线程在调用 acquireQueued 方法的时候是不会响应中断请求的。

cancelAcquire：

// cancelAcquire方法
private void cancelAcquire(Node node) {
	// 如果当前节点为null，结束，健壮性判断
    if (node == null)
        return;
	// node不为null的前提下执行

	// 将当前node的线程置位null  ， 竞争锁资源跟我没有关系了，
    node.thread = null;

	// 获取当前节点的前驱节点
    Node pred = node.prev;
	// 前驱节点的状态 > 0
    while (pred.waitStatus > 0)
		// 找到前驱中最近的非失效节点
        node.prev = pred = pred.prev;

	// 将第一个不是失效节点的后继节点声明出来
    Node predNext = pred.next;

	// 将当前节点置位失效节点。给别的Node看的。
    node.waitStatus = Node.CANCELLED;

	// 如果当前节点是尾节点，将尾节点设置为最近的有效节点（如果当前节点为尾节点的操作）
    if (node == tail && compareAndSetTail(node, pred)) {
		// 用CAS方式将尾节点的next设置null
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
		// 中间节点操作
		// 如果上一个节点不是头节点
        if (pred != head &&
			获取上一届点状态，是不是有效
            ((ws = pred.waitStatus) == Node.SIGNAL ||  // pred需要唤醒后继节点的
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);  // 尝试将pred的前驱节点的next指向当前节点的next（必须是有效的next节点）
        } else {
			// 头结点，唤醒后继节点
            unparkSuccessor(node);
        }
        node.next = node; // help GC
    }
}
我可能是个假开发
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AQS和ReentrantLock.pdf
06-29
AQS和ReentrantLock.pdf
带你看看Java的锁(一)-ReentrantLock
01-20
带你看看Javad的锁-ReentrantLock前言...AQS一共花了5篇文章，对里面实现的核心源码都做了注解 也和大家详细描述了下，后面的几篇文字我将和大家聊聊一下AQS的实际使用，主要会聊几张锁，第一篇我会和大家聊下Reen
AQS-ReentrantLock源码
weixin_37375983的博客
04-01 123
AQS-ReentrantLock解析
Jasonzhou
05-30 170
前言 AQS（ AbstractQueuedSynchronizer ）是一个用来构建锁和同步器（所谓同步，是指线程之间的通信、协作）的框架，Lock 包中的各种锁（如常见的 ReentrantLock, ReadWriteLock）, concurrent 包中的各种同步器（如 CountDownLatch, Semaphore, CyclicBarrier）都是基于 AQS 来构建，所以理解 AQS 的实现原理至关重要，AQS 也是面试中区分侯选人的常见考点。 正文 1.AQS实现原理 AQS 全称
【Java 并发编程】深入理解 AQS - ReentrantLock 源码分析
迪曼奥特迦-博客
05-30 689
AQS，全名 AbstractQueuedSynchronizer，是一个抽象同步队列，它的内部通过维护一个状态 volatile int state（共享资源的状态），一个 FIFO 线程等待队列来实现同步功能。Java 并发包很多工具类底层都是基于 AQS 来实现的，比如：Lock 工具 ReentrantLock、栅栏 CountDownLatch、信号量 Semaphore 等。
AQS-ReentrantLock公平与非公平
weixin_45870815的博客
04-08 89
ReentrantLock-公平锁 公平性 当线程CAS失败之后会进入Node双链表的阻塞队列中，Node大概结构如下： thread：线程 waitestate节点的生命状态：信号量 SIGNAL = -1 //可被唤醒 CANCELLED = 1 //代表出现异常，中断引起的，需要废弃结束 CONDITION = -2 // 条件等待 PROPAGATE = -3 // 传播 0 - 初始状态Init状态 一个Head头，一个Tail尾部，这两个节点thread均为空 需要注意head.waitSta
AQS - ReentrantLock - 非公平锁
FeeLing
03-09 100
加锁过程
AQS-ReentrantLock源码分析
weixin_43598533的博客
04-15 765
AQS-ReentrantLock源码分析
AQS-ReentrantLock重入锁
路辉的博客
03-22 84
Lock简介 Lock是一个接口，synchronized是一个关键字，Lock比synchronized更灵活，有很多实现，更适合并发编程 Lock实现 ReentrantReadWriteLock读写锁 维护了一对锁，一个读锁，一个写锁 读锁和读锁之间共享 写锁和写锁、读锁都互斥 保证数据线程安全的前提下，提高了吞吐量，比单纯的互斥锁性能要好 ReentrantLock重入锁 ReentrantLock是关键，主要以它为例来分析 ReentrantLock重入锁的设计意义 类图如下 值得一提的是,Syn
AQS-ReentrantLock.CyclicBarrier 源码
u014223536的专栏
04-12 93
1，简单介绍 多个线程等待到达一个点后，再继续执行。这里阻塞的是子线程，非主线程。countDownLatch阻塞的是主线程 2，源码分析 构造器 parties表示线程数，barrierAction表示线程全部到达栅栏后需要执行的方法，注意：这个方法又最后一个到达该栅栏的线程来执行（具体看下面源码） public CyclicBarrier(int parties, Runnable barrierAction) { if (parties <= 0) thro.
AQS-ReentrantLock实现原理
weixin_34107739的博客
03-26 99
AbstractQueuedSynchronizer （AQS）类如其名，抽象的队列式同步容器，AQS定义类一套多线程访问共享资源的同步器，许多同步类的实现都依赖于它，比如之前学习的ReentrantLock/Semaphore/CountDownLatch。 1.AQS AQS阻塞队列.png1。自定义同步器在实现时只需要实现共享资源state的获取于释放方式即可，至于具体线程等待队列的...
详解java并发之重入锁-ReentrantLock
08-26
ReentrantLock 的锁机制是基于 AQS（Abstract Queued Synchronizer）的，AQS 是 Java 中的一个同步器框架。ReentrantLock 使用了 AQS 来实现锁机制。 ReentrantLock 的锁机制可以分为两部分：公平锁和非公平锁。 1...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
ReentrantLock的内部类Sync继承自AQS，进一步分为FairSync（公平锁）和NonfairSync（非公平锁）两个子类。公平锁确保线程按照它们请求锁的顺序获取锁，而非公平锁则不保证这种顺序，可能会有线程插队获取锁。 **...
【并发编程】简单化理解AQS和ReentrantLock.pdf
05-03
资源内容 基本概念：介绍并发编程的基本概念，如进程、线程、并行与并发的区别等。 同步机制：讲解如何使用锁、信号量、原子操作等同步机制来避免竞态条件和死锁。 并发模型：介绍不同的并发模型，如生产者-消费者...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 311
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1103
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 147
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 590
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java并发编程深度解析：AQS与ReentrantLock实战
"Java并发编程的关键在于理解和掌握抽象队列同步器（AQS）及其在ReentrantLock等并发工具中的应用。AQS是Doug Lea创造的，它为线程同步提供了一种高效的抽象框架，是Java并发编程的核心组件。" AQS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值