AbstractQueuedSynchronizer 源码学习基于 JDK 1.8

最新推荐文章于 2024-11-04 23:24:03 发布
最新推荐文章于 2024-11-04 23:24:03 发布
阅读量92 收藏
点赞数
分类专栏： Java 多线程 文章标签： AQS 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013151053/article/details/117396464
版权

概览

AbstractQueuedSynchronizer 提供原子式管理同步状态、阻塞和唤醒线程功能以及队列模型的简单框架。

使用设计模式——模板方法，子类只需要实现很少几个接口，就可以定一个锁同步类，完成独占锁，共享锁的逻辑。

参考美团点评技术团队编写的：从ReentrantLock的实现看AQS的原理及应用 加上自己的理解来加深对 AQS 的理解。

本文暂时只介绍 AQS 独占加锁与解锁过程实现

ReentrantLock 与 AQS 关联

根据源码可知，ReentrantLock 的非公平锁加锁，只用实现 tryAcquire 获取锁的逻辑，就可以完成非公平的独占锁获取。其中获取锁失败进行等待的逻辑 AQS 已经帮我们实现。
在这里插入图片描述

1. 独占加锁 acquire 实现

// AQS acquire 方法
public final void acquire(int arg) {
	// 首先调用子类 tryAcquire 去获取锁，若获取锁失败，才执行后面的 addWaiter acquireQueued 逻辑
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt(); // 获取锁成功，当前线程中断
}

主要方法：

  • tryAcuire，子类重写获取锁的逻辑
  • addWaiter，添加节点到队列末尾
    • enq ，入队以及初始化队列
  • acquireQueued，返回 node 在等待过程中是否被中断过
    • shouldParkAfterFailedAcquire，阻塞获取锁失败的线程，删除队列中状态为取消的节点
    • parkAndCheckInterrupt，真正的阻塞办法
    • cancelAcquire，获取锁过程中发生了异常

1.1 tryAcquire

子类复写 tryAcquire 方法，里面实现获取锁逻辑，获取成功返回 true，获取失败返回 false。

参考 ReentranLock 灯同步类的实现，主要逻辑是 setState ，并将当前线程标记为已获取到该锁

1.2 addWaiter

将节点插入到队列尾部，若队列为初始化，先进行初始化

// 将 EXCLUSIVE 类型的 Node 添加到队列尾部
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 插入到队列尾部
        node.prev = pred; // 队列是双向的，将 node 的前置指针指向 pred
        if (compareAndSetTail(pred, node)) {  // 这个方法就是将 tailOffset 的值与 pred 进行比较，若相同，将 tailOffset 的值设为 node，即将 tail 指向 node。
            pred.next = node;  // pred.next 指向 node  
            return node;  // 返回刚刚添加的 node
        }
    }
    // 尾节点为空（队列中没有元素，需要初始化）
    // 或者 compareAndSetTail 失败（tailOffset 处的值不是 pred，被其它线程修改，导致 tail 指向的节点和 pred 指向的节点不同）
    enq(node); // 死循环方式 插入到队列中
    return node;  // 返回刚刚添加的 node
}

// 插入节点到队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        // 尾指针为 null
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))  // 队列初始化
                tail = head; // ，head 和 tail 指向同一处，进行下一次循环
        } else {
        	// 队列中有元素
            node.prev = t;   // node 的前置指针指向 tail
            if (compareAndSetTail(t, node)) {  // 若 tailOffset 指向的值等于 t，将 tail 处的值改为 node
                t.next = node;  // 队列是双向的，将后置指针指向 node
                return t;  // 返回插入队列前 队列中的最后一个节点
            }
        }
    }
}

1.3 acquireQueued

循环从队列中查询 node 节点能否获取锁，直到线程获取成功或者被中断

// node 是刚刚插入队列结尾的节点，死循环去判断 node 是否获取到锁，返回是否被中断
final boolean acquireQueued(final Node node, int arg) {
	// 获取失败标志位
    boolean failed = true;
    try {
    	// 是否被中断
        boolean interrupted = false;
        // 死循环，直到获取锁成功
        for (;;) {  
        	// 刚刚插入节点 node 的前置节点
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) { // 若前置节点是头节点（头节点里面啥都没有），并且当前 Node 获取锁成功
                setHead(node);  // head 指针后移指向 node，并将 node 属性置为 null
                p.next = null; // help GC
                failed = false;
                return interrupted; 
            }
            // 上面条件不满足：p 不是头节点 或者 node 没有获取到锁
            // shouldParkAfterFailedAcquire 若锁获取失败，返回线程是否需要被阻塞
            // parkAndCheckInterrupt 阻塞当前线程(for 循环卡住)，并返回当前线程是否被中断
            // 这个方法块的意思：循环判断 node 是否需要被阻塞，并进行阻塞直到被唤醒
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())  
                // 被中断过
                interrupted = true;
        }
    } finally {
    	// 出现不正常情况，取消获取锁
        if (failed)
            cancelAcquire(node);  // 后面讲
    }
}

1.3.1 shouldParkAfterFailedAcquire

// waitStatus 状态列举：
static final int CANCELLED =  1; // 取消状态
static final int SIGNAL    = -1;  // 后继线程需要解锁
static final int CONDITION = -2; // 等待某个条件的状态
static final int PROPAGATE = -3;  // 获取共享锁传播状态 

// 根据前驱节点 pred 判断 node 是否需要被阻塞
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	// 
    int ws = pred.waitStatus;
    // 前驱节点处于 唤醒状态，
    if (ws == Node.SIGNAL)
        return true;  // 那么返回需要被阻塞，被唤醒下面说
    // 若前驱节点处于取消状态，移除队列中 node 前面处于取消状态的节点
    if (ws > 0) {
        do {
        	// 往前遍历，直到找到队列中，节点不是 取消状态 的节点，将 node 的前置指向指向这个节点。
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 取消状态的节点，就从队列中移除了
        pred.next = node;
    } else {
    	// 将前置节点的 waitStatus 设为 SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回不需要被阻塞
    return false;
}

1.3.2 parkAndCheckInterrupt

// 挂起当前线程，并返回当前线程的中断状态
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

1.3.3 cancelAcquire

private void cancelAcquire(Node node) {
    // Ignore if node doesn't exist
    if (node == null)
        return;
    node.thread = null;
    Node pred = node.prev;
    while (pred.waitStatus > 0) // 往前遍历，跳过 waitStatus = CANCELLED 的节点
        node.prev = pred = pred.prev;  
    Node predNext = pred.next;  // 删除中间 waitStatus = CANCELLED 的节点，pred.next 指向 node
    // 将 node 状态改为 CANCELLED
    node.waitStatus = Node.CANCELLED;
    // 如果 node 是尾节点，直接删除末尾的 node
    if (node == tail && compareAndSetTail(node, pred)) {
    	// pred 指向 predNext，predNext 为空节点
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        // 当 pred 不是头节点，并且 pred.waitStatus == SIGNAL 时
        // 或者 pred 不是头节点，并且 pred.waitStatus 不是 CANCELLED 状态，将 pred.waitStatus 改为 SIGNAL
        // 以上两种情况出现时，将 pred.next 指向 node.next。即删除 pred 指向 node 的指针，直接指向 node.next 
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);  //
        } else {
        	// 上面条件不满足，即：
        	// pred 是头节点
        	// pred 状态为 CANCELLED 
        	// pred.thread == null
        	// 以上三种情况出现时，唤醒 node 后面阻塞的线程
            unparkSuccessor(node);
        }
        node.next = node; // help GC
    }
}

// 唤醒 node 后面的线程
private void unparkSuccessor(Node node) {

    int ws = node.waitStatus;
    if (ws < 0) // 不是 CANCELLED 状态时，把 node.waitStatus 设为 0
        compareAndSetWaitStatus(node, ws, 0);
   
    Node s = node.next;
    // 若 node 的后继节点为空，或者后继节点时 CANCELLED
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 从尾节点开始往前遍历，找到队列中从左往右第一个不是 CANCELLED 状态的节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
    	// 唤醒该节点
        LockSupport.unpark(s.thread);
}
  • 从尾节点开始往前遍历，找到第一个非 CANCELLED 节点的原因

addWaiter 方法节点入队 node.prev = pred; compareAndSetTail(pred, node) 不是原子操作，所以 pre 指针是完整的

其次，删除 CANCELLED 节点时，先删除的时 NEXT，Prev 没有改，所以可以完整遍历整个队列

1.4 acquire 方法总结

acquire 方法的总体思路：

  1. tryAcquire 子类实现获取锁逻辑，获取成功，方法结束
  2. 获取失败，通过 addWaiter 加入到队列结尾，并初始化未初始化的队列
  3. acquireQueued 循环判断 node 节点是否能获取到锁，里面做了几件事：
    • 当 node 节点前置节点是 head 并且再次尝试获取锁成功，直接返回
    • 判断获取失败的 node 节点是否需要被阻塞，里面会去删除队列中 waitstatus 为 CANCELLED 状态的节点，并返回线程的中断状态，若被阻塞，acquireQueued 中的 for 循环将被卡住，等待被唤醒
    • 获取锁期间发生异常，将队列中的 node 删除
  4. 跳出 acquireQueued 循环的条件是 node 前置节点是 head 并且获取到锁，否则进行阻塞等待
    在这里插入图片描述

2. 独占解锁实现

释放锁，调用 子类重写的 tryRelease 方法，若解锁成功，将唤醒 head 后面的 node

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        // 当头指针已经初始化
        // waitStatus == 0，表示后继节点正在运行中，不需要唤醒
        // waitStatus < 0，表示节点状态不是 CANCELLED，那么需要被唤醒
        
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

2.1 tryRelease

ReentranLock tryRelease 释放锁实现，公平锁和非公平锁都一样

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;
        // 将当前锁的所占线程置为 null
        setExclusiveOwnerThread(null);
    }
    // 更新 state
    setState(c);
    return free;

2.2 unparkSuccessor
unparkSuccessor 在上面 1.3.3 有介绍

3. 可中断加锁实现

逻辑基本与 acquire 一致，唯一不同的地方就是阻塞等待获取锁过程中，如果被中断，直接抛出异常。

public final void acquireInterruptibly(int arg)
        throws InterruptedException {
    // 如果当前线程被中断，直接抛出    
    if (Thread.interrupted())
        throw new InterruptedException();
    // 子类获取锁失败    
    if (!tryAcquire(arg))
    	// 执行具体的可中断的加锁逻辑
        doAcquireInterruptibly(arg);
}

// 这个方法和 acquireQueued 基本一样，唯一不同的就是等待过程中，线程被中断直接抛出（parkAndCheckInterrupt 返回 true）
private void doAcquireInterruptibly(int arg)
    throws InterruptedException {
    // 添加节点到队列尾部
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                // 与 acquireQueued 不同点
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

4. 超时等待式获取锁

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);      // 子类获取锁成功 或者 doAcquireNanos 获取成功
}

// 一个时间阈值，若时间小于该值，不阻塞当前线程而是继续获取，提高响应速度
static final long spinForTimeoutThreshold = 1000L;

private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    // 超时时间点    
    final long deadline = System.nanoTime() + nanosTimeout;
    // 添加到队列尾部
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            // 获取锁成功
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            // 计算与截止时间的差距
            nanosTimeout = deadline - System.nanoTime();
            // 已经超时，直接返回 false
            if (nanosTimeout <= 0L)
                return false;
            // 阻塞获取锁并且差距要大于 1000，
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                // 指定阻塞指定时间
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
菜鸟日常
关注
专栏目录
java jdk1.8源码下载_GitHub - raysonfang/jdk1.8-source-analysis: JDK1.8源码分析
weixin_39582569的博客
02-24 519
jdk1.8-source-analysisJDK1.8源码分析导入源码过程中的注意事项JDK1.8对应JDK版本下载：JDK1.8 提取码：49wi源码在src目录下以下两个类手动添加的，解决编译过程中该包的丢失sun.font.FontConfigManagersun.awt.UNIXToolkit其中：1.请手动添加jdk下面的lib到path中2.lib文件夹下面的junit测试jar包添...
【JUC】JDK1.8源码分析之AbstractQueuedSynchronizer（二）
weixin_34301307的博客
04-08 149
一、前言 　　在锁框架中，AbstractQueuedSynchronizer抽象类可以毫不夸张的说，占据着核心地位，它提供了一个基于FIFO队列，可以用于构建锁或者其他相关同步装置的基础框架。所以很有必要好好分析。 二、AbstractQueuedSynchronizer数据结构 　　分析类，首先就要分析底层采用了何种数据结构，抓住核心点进行分析，经过分析可知，AbstractQueued...
JDK1.8 AbstractQueuedSynchronizer的实现分析（学习笔记）
weiythi的Blog
12-05 705
lock方法会调用acquire方法，该方法在AQS中实现 public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }正常使用一个Ree
AbstractQueuedSynchronizer从设计到实现
简单，坚持
07-18 435
博客的代码部分理解，建议通过观看免费课程：https://edu.csdn.net/course/play/25414/301464 概念导入 在并发编程中一个很重要的概念就是锁，本文以java中对锁的实现为例子做一个分析。我们使用锁的场景一般是这样的：在程序中需要对某些关键代码块做并发控制，只有满足条件的线程允许访问。那么这里就有这样几个概念：锁的持有线程、等待线程、调度控制中...
JAVA 锁的机制（美团技术文章）
一个后端菜鸟的博客
11-23 203
偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态。升级为重量级锁时，锁标志的状态值变为“10”，此时Mark Word中存储的是指向重量级锁的指针，此时等待锁的线程都会进入阻塞状态。是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。
深度解析Java 8：JDK1.8 AbstractQueuedSynchronizer的实现分析（上）
青色刀客的专栏
08-13 867
前言 Java中的FutureTask作为可异步执行任务并可获取执行结果而被大家所熟知。通常可以使用future.get()来获取线程的执行结果，在线程执行结束之前，get方法会一直阻塞状态，直到call()返回，其优点是使用线程异步执行任务的情况下还可以获取到线程的执行结果，但是FutureTask的以上功能却是依靠通过一个叫AbstractQueuedSynchronizer的类来实现，
ReentrantLock 源码学习基于 JDK1.8
菜鸟日常
05-24 130
1. 概况 ReentrantLock 是可重入的，也就是说如果当前线程拥有这把锁，进入到下一个加了同样锁的方法中时，不用等待直接获取，只是对象头字段增加了一个标记，标记进入了两次。 比 Synchronized 更加灵活，多一个尝试获取锁的办法，和获取锁超时时间 2. 类定义 public class ReentrantLock implements Lock, java.io.Serializable { } ReentrantLock 实现 Lock 接口，Lock 接口包含包含以下几
CountDownLatch 源码学习基于JDK1.8
菜鸟日常
05-27 135
1. 概况 栅栏：多个线程一起等待，直到任务都完成 2. 类定义 3. 成员变量 只有一个成员变量 Sync ，同步逻辑主要由内部类 Sync 实现 private final Sync sync; 4. 构造方法 构造方法直接调用内部类 Sync 的构造方法 public CountDownLatch(int count) { if (count < 0) throw new IllegalArgumentException("count < 0"); this.sync =
java多线程 之 AQS
s20082043的专栏
09-12 596
Java中的FutureTask作为可异步执行任务并可获取执行结果而被大家所熟知，通常可以使用future.get()来获取线程的执行结果，在线程执行结束之前，get方法会一直阻塞状态，直到call()返回，其优点是使用线程异步执行任务的情况下还可以获取到线程的执行结果，但是FutureTask的以上功能却是依靠通过一个叫AbstractQueuedSynchronizer的类来实现，至少在JDK
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 401
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 917
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 965
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 958
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
spring循环依赖解决方式
qq_36400213的博客
11-04 482
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 326
默认对常规Session的理解和使用，如何使用Set-Cookie。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
最新发布
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 191
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 314
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 130
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
JavaScript的第十一天
全栈学习ing
10-31 750
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
深入解析JDK1.8 ArrayList源码
"这篇分析基于JDK1.8的ArrayList源码，主要探讨ArrayList的核心特性，包括构造函数、成员变量、元素操作等。ArrayList作为Java中的动态数组，其内部使用一个Object类型的数组来存储元素，提供了高效查找但相对低效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值