【JUC】共享模型之内存

最新推荐文章于 2025-11-23 23:13:13 发布
原创 最新推荐文章于 2025-11-23 23:13:13 发布 · 790 阅读 · 29 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#后端 #java

1. 概述

上一小节主要介绍了《共享模型之管程》相关内容，介绍了在 Java 层面如何使用synchronized关键字保证多个线程并发运行的原子性，而本章聚焦于JMM（Java Memory Model）层面，深入了解主存、工作内存相关原理与运行流程，本章重点需要解决以下三方面问题：

  • 原子性：保证临界区代码执行的原子性（可通过悲观锁实现）
  • 可见性：保证指令执行不会受到缓存的影响（一个线程的修改操作对其他线程可见）
  • 有序性：保证指令执行顺序不会受到 CPU 并行优化干扰

2. 可见性

2.1 问题引入

我们先来看看下面这段代码的效果：

/**
 * 测试可见性
 * @author ricejson
 */
@Slf4j
public class TestVisible {
    private static boolean isStop = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (!isStop) {

            }
            log.debug("任务运行结束...");
        }, "work").start();
        // 睡眠1s后设置工作线程停止运行
        TimeUnit.SECONDS.sleep(1);
        isStop = true;
        log.debug("主线程退出...");
    }
}

这段代码本意是主线程在 1s 后睡眠结束并设置isStop变量为 true，此处工作线程访问变量不满足循环条件后退出运行（以此达到中断工作线程运行的效果），但是实际效果如下图所示。

现象说明当主线程退出后（一定将 isStop 设置为true），工作线程访问到的isStop变量仍然为 false，造成无法退出循环的现象

2.2 可见性分析

想要知道2.1小节为什么会造成这种现象的原因？我们必须要掌握 JMM 当中主内存、工作内存的运行机制，如下图所示。

其实不难分析，按照原先的程序运行过程，work线程需要每次循环都获取到主内存当中的变量值，因此JVM当中的 JIT 会进行优化：将主内存的变量缓存到工作内存当中，因此后续即使主线程对主内存的变量进行修改，work线程访问的始终是工作内存的缓存结果（主内存变量对工作线程不可见）

2.3 解决方案

解决办法很简单，只需要在对应的变量定义上加上volatile关键字，该关键字可以用于控制变量访问始终通过主内存获取，修改后的代码如下：

/**
 * 测试可见性
 * @author ricejson
 */
@Slf4j
public class TestVisible {
    private volatile static boolean isStop = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (!isStop) {

            }
            log.debug("任务运行结束...");
        }, "work").start();
        // 睡眠1s后设置工作线程停止运行
        TimeUnit.SECONDS.sleep(1);
        isStop = true;
        log.debug("主线程退出...");
    }
}

运行效果如下：

2.4 扩展—两阶段终止模式

2.4.1 背景

当前的两阶段终止模式代码如下：

/**
 * 测试两阶段终止模式
 * @author ricejson
 */
@Slf4j
public class TestTwoPhaseTerminating {
    public static void main(String[] args) throws InterruptedException {
        Thread monitor = new Thread(() -> {
            Thread thread = Thread.currentThread();
            while (true) {
                if (thread.isInterrupted()) {
                    // 被终止
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("执行系统监控...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 设置中断标记
                    thread.interrupt();
                }
            }
        }, "monitor");
        monitor.start();
        TimeUnit.SECONDS.sleep(3);
        // 中断线程运行
        monitor.interrupt();
    }
}

❗ 注意：该代码存在的问题

使用interrupt方法进行终止的方案，很容易在catch块遗漏interrupt方法（sleep线程被打断会清除中断标记）

2.4.2 可见性优化

我们可以尝试自定义标记变量用来控制监控进程是否继续运行，改造代码如下：

/**
 * 两阶段终止模式优化-可见性
 * @author ricejson
 */
@Slf4j
public class TestTwoPhaseTerminatingV2 {
    private static volatile boolean isStop = false;
    public static void main(String[] args) throws InterruptedException {
        Thread monitor = new Thread(() -> {
            while (true) {
                if (isStop) {
                    // 被终止
                    isStop = false; // 重置为false
                    break;
                }
            }
        }, "monitor");
        monitor.start();
        TimeUnit.SECONDS.sleep(3);
        // 中断线程运行
        isStop = true;
        monitor.interrupt(); // 如果是sleep则立即唤醒
    }
}

💡 提示：这里一定需要给 isStop 变量使用 volatile 关键字修饰，因为存在可见性问题！

2.4.3 犹豫模式优化

以上代码仍有优化空间——如果在多线程环境下，启动多个线程运行 start 方法就会启动多个监控线程（冗余）因此可以通过一个变量来控制是否启动新的监控线程，改造后的代码如下：

/**
 * 两阶段终止模式优化-犹豫模式
 * @author ricejson
 */
@Slf4j
public class TestTwoPhaseTerminatingV3 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTerminating tpt = new TwoPhaseTerminating();
        tpt.start();
        tpt.start();
        TimeUnit.SECONDS.sleep(3);
        tpt.stop();
    }
}

class TwoPhaseTerminating {
    public static volatile boolean isStop = false;
    public static volatile boolean starting = false;
    public static Thread monitor = null;
    public void start() {
        synchronized (this) {
            if (starting) {
                // 不启动新的
                return;
            }
            starting = true;
        }
        monitor = new Thread(() -> {
            while (true) {
                if (isStop) {
                    // 被终止
                    isStop = false; // 重置为false
                    starting = false;
                    break;
                }
            }
        }, "monitor");
        monitor.start();
    }

    public void stop() {
        // 中断线程运行
        isStop = true;
        monitor.interrupt(); // 如果是sleep则立即唤醒
    }
}

💡 提示：

  1. 这里需要加上 synchronized 保证多个线程代码之间的原子性
  2. 这里一定需要给 starting 变量使用 volatile 关键字修饰，因为存在可见性问题！（synchronized只能保证内部可见性）

3. 有序性

3.1 指令重排序

JVM在不影响代码的运行结果的前提下，有可能会调换代码指令的执行顺序，从而导致了程序运行结果的异常

int i = 10;
int j = 20;

例如上述代码可能会被 JMM 优化为以下代码顺序：

int j = 20;
int i = 10;

3.2 问题演示

使用 maven 工具并添加以下依赖：

<!--
Copyright (c) 2017, Red Hat Inc.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

 * Neither the name of Oracle nor the names of its contributors may be used
   to endorse or promote products derived from this software without
   specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
-->

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.concurrent</groupId>
    <artifactId>jcstress_ordering</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>


    <!--
       This is the demo/sample template build script for building concurrency tests with JCStress.
       Edit as needed.
    -->

    <prerequisites>
        <maven>3.0</maven>
    </prerequisites>

    <dependencies>
        <dependency>
            <groupId>org.openjdk.jcstress</groupId>
            <artifactId>jcstress-core</artifactId>
            <version>${jcstress.version}</version>
        </dependency>
    </dependencies>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <!--
            jcstress version to use with this project.
          -->
        <jcstress.version>0.5</jcstress.version>

        <!--
            Java source/target to use for compilation.
          -->
        <javac.target>1.8</javac.target>

        <!--
            Name of the test Uber-JAR to generate.
          -->
        <uberjar.name>jcstress</uberjar.name>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <compilerVersion>${javac.target}</compilerVersion>
                    <source>${javac.target}</source>
                    <target>${javac.target}</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <id>main</id>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>${uberjar.name}</finalName>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>org.openjdk.jcstress.Main</mainClass>
                                </transformer>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/TestList</resource>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

添加如下类代码（src/main/java/org/example/TestOrdering.java）：

package org.example;

import org.openjdk.jcstress.annotations.Actor;
import org.openjdk.jcstress.annotations.Expect;
import org.openjdk.jcstress.annotations.JCStressTest;
import org.openjdk.jcstress.annotations.Outcome;
import org.openjdk.jcstress.annotations.State;
import org.openjdk.jcstress.infra.results.I_Result;


@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class TestOrdering {
    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

使用 maven 相关工具进行打包成 jar 包后运行，效果如下：

可以发现，出现最终结果为 0 的情况为 266 次（极低概率但仍存在），这说明确实存在指令重排序的过程

3.3 解决方案

解决方法也非常简单，同样是依赖于volatile关键字，此时被该关键字修饰的变量之前的代码都不会被优化执行顺序，修改相关代码重新运行结果，效果如下：

4. volatile 原理

volatile 关键字的底层实现是内存屏障技术（Memory Barrier）

  • 对于volatile修饰的变量的写指令后会加入写屏障
  • 对于volatile修饰的变量的读指令之前会加入读屏障

4.1 可见性原理

示例代码如下：

public class TestVisible {
    private volatile static boolean isStop = false;
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (!isStop) {

            }
            log.debug("任务运行结束...");
        }, "work").start();
        // 睡眠1s后设置工作线程停止运行
        TimeUnit.SECONDS.sleep(1);
        isStop = true;
        log.debug("主线程退出...");
    }
}

由于对于isStop变量使用了volatile关键字进行修饰，会产生以下效果：

  1. main线程中对于isStop变量产生了写指令，因此会加上写屏障，之前的代码都会强制写入主存中
  2. work线程中对于isStop变量产生了读指令，因此会加上读屏障，之后的代码都会强制从主存中获取

4.2 有序性原理

示例代码如下：

@JCStressTest
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class TestOrdering {
    int num = 0;
    volatile boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

于对于ready变量使用了volatile关键字进行修饰，会产生以下效果：

  1. actor2线程中对于ready变量产生了写指令，因此会加上写屏障，之前的代码无法被重排序到该写指令之后
  2. actor1线程中对于ready变量产生了读指令，因此会加上读屏障，之后的代码无法被重排序到该读指令之前

4.3 double-checked-locking 问题

以著名的单例模式的 DCL 问题为例：

public final class Singleton {
    private Singleton() { }
    private static Singleton INSTANCE = null;
    public static Singleton getInstance() {
        if(INSTANCE == null) { // t2
            // 首次访问会同步，而之后的使用没有 synchronized
            synchronized(Singleton.class) {
                if (INSTANCE == null) { // t1
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

上述代码具有指令重排序的问题，JVM 层面的INSTANCE = new Singleton();操作会产生如下指令：

  1. new：开辟内存、创建对象
  2. dup：复制引用地址
  3. invokespecial：调用构造方法完成初始化
  4. putstatic：完成引用赋值

因此在多线程环境下，如果发生了指令重排序过程，导致 4 指令在 3 指令之前执行，另一个线程判断 INSTANCE 不为 null 于是直接返回使用了未初始化的对象，会造成非法的结果，解决方案就是给 INSTANCE 变量使用 volatile关键词修饰，此时保证 3 操作一定在 4 操作之前完成

❗ 注意：synchronized能保证原子性、可见性、有序性，但需要注意以下要点

  1. 共享变量被 synchronized 完全包裹时才能保证有序性
  2. 有序性 ≠ 禁止指令重排序

5. happens-before 规则

happens-before 总结了一套规则用于保证共享变量的可见性与有序性，符合该规则的程序能够保证对于共享变量的写操作对于其他线程对该共享变量读操作可见，下面列举部分规则：

  1. 对于使用 volatile 修饰的共享变量的写操作对于其他线程的读操作可见
  2. 线程释放锁之前对于共享变量的写操作对于加锁的其他线程的读操作可见
  3. 线程start之前的写操作对该线程运行后的读操作可见
  4. 线程结束运行之前的写操作，对于其他已知它结束的读可见（比如 join 等操作）
  5. 传递性规则，如果 A 对于 B 可见且 B 对于 C 可见，那么 A 对于 C 可见
java线程共享模型之管程（锁及其操作）
su_xu_chao的博客
12-17 1147
synchronized锁的常见问题，与认识。
JUC共享模型之内存阶段五
亚索@哈塞给
09-20 249
5. 共享模型之内存 上一章讲解的 Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性。这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题 5.1 Java 内存模型（JMM） JMM 即 Java Memory Model，它从java层面定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。JMM 体现在以下几个方面 原子性 - 保证指令不会受到线程上下文切换的影响 可见性 - 保证指令不会受 cp
jcstress搭建
瞅自己都上火的博客
06-30 208
pom.xml <prerequisites> <maven>3.0</maven> </prerequisites> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <jcstress.version>0.5</jcstress.version> <jav
JUC共享模型之内存---（黑马程序员JUC笔记）
唐昊
02-26 465
Java 内存模型
JUC-共享模型之内存
GreenAmanda的博客
04-11 399
JMM即Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着CPU寄存器、缓存、硬件内存、CPU指令优化等。JMM体现在以下几个方面为什么呢？分析一下：1.初始状态，t线程刚开始从主内存读取了run的值到工作内存。2.因为t线程要频繁从主内存中读取run的值，JIT编译器会将run的值缓存到自己工作内存中的高速缓存区中，减少对主存中run的访问，提高效率。
JUC——共享模型之内存与无锁
m0_51710682的博客
08-01 826
如果 t 线程程频繁从主内存中读取 run 的值，JIT 编译器会将主存中run的值缓存至自己工作内存中的高速缓存中，减少对主存的访问，提高效率。volatile关键字可以用来修饰成员变量和静态成员变量，避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存，保证了。ABA问题：如果在CAS操作执行之前，共享变量的值被改变了多次，且最终又恢复为原始值，那么CAS操作可能会误以为共享变量的值没有发生变化，导致数据的不一致。类来解决 ABA 问题。
JUC笔记-共享模型之内存
weixin_50255400的博客
02-06 613
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
JUC4-共享模型之内存
m0_73902080的博客
08-18 1002
JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
JUC学习笔记——共享模型之内存
2401_83384536的博客
05-20 593
在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做 了，直接结束返回设置某个方法只能调用一次适用于单例对象的构造方法。
JUC学习之共享模型之内存
m0_53157173的博客
12-25 632
JUC学习之共享模型之内存Java 内存模型可见性退不出的循环解决方法两阶段终止模式interrupt实现volatile实现同步模式之 Balking定义实现指令重排有序性指令级并行原理名词Clock Cycle TimeCPIIPC鱼罐头的故事指令重排序优化支持流水线的处理器SuperScalar 处理器CPU 缓存结构原理1. CPU 缓存结构2.CPU 缓存读3. CPU 缓存一致性诡异的结果解决方法volatile 原理内存屏障1. 如何保证可见性2.如何保证有序性volatile 不能解决指令交
（四）共享模型之内存
dingd1234的博客
07-13 703
Balking（犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回。
JUC共享模型之无锁并发阶段六
亚索@哈塞给
09-20 311
6. 共享模型之无锁 管程即monitor是阻塞式的悲观锁实现并发控制，这章我们将通过非阻塞式的乐观锁的来实现并发控制。 友情提示：无锁并发就是不需要锁控制并发 6.1 问题提出 有如下需求，保证account.withdraw取款方法的线程安全 public class Test5 { public static void main(String[] args) { Account.demo(new AccountUnsafe(10000)); } } cl
【JUC】第五章：共享模型之内存
小新的博客
08-08 952
但是上面这样的代码是不够好的，如果我们已经创建好一个实例了，其他线程使用这个实例的时候还是会竞争锁，每个线程都要竞争锁，这样会严重影响性能，只要实例创建成功之后，其他线程应该直接拿到这个实例，不应该再去竞争锁。比如：a=1，b=a；d的，有序性的前提是，在synchronzied代码块中的共享变量，不会再代码块中使用到，否正有序性不能被保证，只能使用。每个线程都有自己独立的工作内存，里面保存着该线程使用到的变量的副本。当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看到修改的值。
共享模型之内存
weixin_50458070的博客
10-13 154
黑马juc
11.20 开源APP
2503_93413701的博客
11-20 1128
项目地址 全部代码的链接在。
Rust高性能Web后端服务开发与Actix-Web实战分享：零成本抽象、高并发处理与内存安全实践
最新发布
2501_94181083的博客
11-23 593
数据序列化使用bincode替代 JSON：节省 30% CPU对热点代码进行#[inline]展开Netty 式 Reactor 模型减少线程调度开销批量 DB 提交减少 IO 压力缓存热点业务路径到 Redis最终整个平台达成：单机 QPS：18 万P99 延迟 < 30msCPU 占用在可控范围内资源释放完全可预期，无内存泄漏风险高性能，无 GC 停顿编译期保证内存安全，避免线上事故Actix-Web 性能强劲，适合高并发系统适合对性能和稳定性要求极高的互联网生产环境。
初识JDBC
t2786024916的博客
11-23 252
DriverManager - 驱动管理类 - 负责管理数据库驱动连接Connection - 数据库连接类 - 建立与数据库的连接（包含用户名、密码、URL等参数）Statement - SQL语句执行器 - 用于编译和执行SQL操作指令ResultSet - 结果集对象 - 存储并封装SQL查询返回的结果数据 3.连接数据库 4.操作数据库 5.返回结果 增删改不需要resultSet = statement.executeQuery(sql);//执行SQl语句直接 4
前后端交互（Servlet+HTML+JDBC）
2501_91483977的博客
11-23 601
涵盖前后端的概念、流程及实现：前端通过表单、AJAX 发送 GET/POST 请求，后端以 Servlet 为核心，通过 HttpServletRequest 收参、HttpServletResponse 响应，支持文字、HTML、JSON 三种返回格式。还整合 JDBC 实现数据持久化，补充 HTTP 状态码与常见问题排查
My-Agent - 基于Java和Spring AI的智能体开发平台
持续分享有趣的技术干货
11-19 693
My-Agent是一个基于Java和SpringAI构建的智能体开发平台，采用前后端分离架构（React+SpringBoot），提供完整的AI智能体生命周期管理方案。核心特性包括：多模型支持（OpenAI/Ollama等）、可视化工作流编排、知识库检索（基于PgVector）以及工具集成扩展能力。平台采用模块化设计，支持流式对话、对话记忆管理等交互功能，并具备完善的监控与安全机制（JWT认证）。技术栈涵盖JDK21、SpringBoot3、MySQL8、PostgreSQL（PgVector）和Redis
Java并发编程深度解析：JUC实战与理论结合
第五章"共享模型之内存"主要关注Java内存模型（JMM），它定义了线程间如何共享和访问内存，包括volatile关键字的作用，以及happens-before原则。 第六章"共享模型之无锁"将带你走进无锁编程的世界，了解无锁数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值