【多线程及高并发 番外篇】虚拟线程怎么被 synchronized 阻塞了？

置顶 已于 2024-04-26 14:48:38 修改
阅读量1.7k 收藏 25
点赞数 52
分类专栏： 多线程及高并发 文章标签： java 虚拟线程 synchronized ReentranLock 多线程
于 2023-12-25 16:05:35 首次发布
觉得此文有帮助的，就点个赞或留个言呐~ 若要转载的话，请注明文章出处哦
本文链接：https://blog.csdn.net/why_still_confused/article/details/135175556
版权

👏作者简介：大家好，我是若明天不见，BAT的Java高级开发工程师，CSDN博客专家，后端领域优质创作者
📕系列专栏：多线程及高并发系列
📕其他专栏：微服务框架系列、MySQL系列、Redis系列、Leetcode算法系列、GraphQL系列
📜如果感觉博主的文章还不错的话，请👍点赞收藏关注👍支持一下博主哦❤️
✨时间是条环形跑道，万物终将归零，亦得以圆全完美

虚拟线程怎么被 synchronized 阻塞了？

多线程及高并发系列

虚拟线程是 Project Loom 的核心概念，它是一种轻量级的线程实现，具有以下关键特点：协作式调度、轻量级堆栈、阻塞不占用线程、与现有代码兼容。虚拟线程的引入旨在提高并发性能和可伸缩性，简化并发编程，并最大程度地利用系统资源

  1. 轻量级线程：虚拟线程是一种轻量级的线程实现，相对于传统的 Java 线程（即操作系统线程）来说，创建和切换虚拟线程的开销更低。因此，可以创建大量的虚拟线程，而不会造成过多的线程开销和资源消耗
  2. 协作式调度：传统的 Java 线程是通过抢占式调度进行线程切换的，由操作系统负责调度线程的执行。而虚拟线程采用的是协作式调度，即线程主动让出执行权，将控制权交给其他线程。这种调度方式可以避免不必要的上下文切换，提高线程的执行效率
  3. 堆栈轻量级：与传统线程相比，虚拟线程的堆栈是轻量级的，占用更少的内存空间。这使得可以创建大量的虚拟线程，而不会导致堆栈溢出或内存消耗过大的问题
  4. 阻塞不占用线程：传统的 Java 线程在执行阻塞操作时，会一直占用底层的操作系统线程，导致资源浪费。而虚拟线程在执行阻塞操作时，会主动释放底层线程，让其可用于执行其他虚拟线程，从而最大程度地利用系统资源
  5. 与现有代码的兼容性：虚拟线程的引入不需要对现有的 Java 代码进行修改。虚拟线程通过Fibers API提供了一种新的编程模型，可以在现有的 Java 应用程序中使用，而无需更改现有的线程管理代码

虚拟线程(Virtual Thread)它不与特定的操作系统线程相绑定。它在平台线程上运行 Java 代码，但在代码的整个生命周期内不独占平台线程。**这意味着许多虚拟线程可以在同一个平台线程上运行他们的 Java 代码，共享同一个平台线程。详见虚拟线程原理及性能分析

虚拟线程实现原理

此段自虚拟线程原理及性能分析

虚拟线程是由 Java 虚拟机调度，而不是操作系统。虚拟线程占用空间小，同时使用轻量级的任务队列来调度虚拟线程，避免了线程间基于内核的上下文切换开销，因此可以极大量地创建和使用

简单来看，虚拟线程实现如下：virtual thread = Continuation + Scheduler + Runnable

  • 虚拟线程会把任务（java.lang.Runnable实例）包装到一个Continuation实例中:
    • 当任务需要阻塞挂起的时候，会调用Continuation.yield()操作进行阻塞，虚拟线程会从平台线程卸载
    • 当任务解除阻塞继续执行的时候，调用Continuation.run()会从阻塞点继续执行
  • Scheduler 也就是执行器，由它将任务提交到具体的载体线程池中执行
    • 它是java.util.concurrent.Executor的子类
    • 虚拟线程框架提供了一个默认的FIFO的ForkJoinPool用于执行虚拟线程任务
  • Runnable 则是真正的任务包装器，由 Scheduler 负责提交到载体线程池中执行

JVM 把虚拟线程分配给平台线程的操作称为 mount（挂载），取消分配平台线程的操作称为 unmount（卸载）：

  • mount 操作：虚拟线程挂载到平台线程，虚拟线程中包装的 Continuation 堆栈帧数据会被拷贝到平台线程的线程栈，这是一个从堆复制到栈的过程
  • unmount 操作：虚拟线程从平台线程卸载，此时虚拟线程的任务还没有执行完成，所以虚拟线程中包装的 Continuation 栈数据帧会留在堆内存中

从 Java 代码的角度来看，其实是看不到虚拟线程及载体线程共享操作系统线程的，会认为虚拟线程及其载体都在同一个线程上运行，因此，在同一虚拟线程上多次调用的代码可能会在每次调用时挂载的载体线程都不一样

启用虚拟线程

spring.threads.virtual.enabled: true

在 Spring Boot 3.2 中启用虚拟线程，只需在application.yml或application.properties文件中设置这个属性

  • Tomcat 将使用虚拟线程处理 HTTP 请求。这意味着处理 Web 请求的代码（如 Controller 中的方法）将在虚拟线程上运行。
  • 在调用 @Async方法时，Spring MVC 的异步请求处理和 Spring WebFlux 的阻塞执行支持现在将使用虚拟线程
  • 注解了@Scheduled的方法将在虚拟线程上运行

JDK 的虚拟线程调度器是一个工作窃取 ForkJoinPool，以先进先出（FIFO ）模式运行。调度器的并行性（parallelism）是指可用来调度虚拟线程的平台线程数。

ForkJoinPool的原理及核心概念可见 parallelStream/ForkJoinPool 详解

虚拟线程创建

方法一：直接创建虚拟线程

Thread vt = Thread.startVirtualThread(() -> {
    System.out.println("hello wolrd virtual thread");
});

方法二：创建虚拟线程但不自动运行，手动调用start()开始运行

Thread.ofVirtual().unstarted(() -> {
    System.out.println("hello wolrd virtual thread");
});
vt.start();

方法三：通过虚拟线程的 ThreadFactory 创建虚拟线程

ThreadFactory tf = Thread.ofVirtual().factory();
Thread vt = tf.newThread(() -> {
    System.out.println("Start virtual thread...");
    Thread.sleep(1000);
    System.out.println("End virtual thread. ");
});
vt.start();

方法四：Executors.newVirtualThreadPerTaskExecutor()

ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> {
    System.out.println("Start virtual thread...");
    Thread.sleep(1000);
    System.out.println("End virtual thread.");
    return true;
});

synchronized 阻塞问题分析

了解了虚拟线程的原理及使用，准备将服务从JDK 17 升级到 JDK 21，准备用虚拟线程尝尝鲜。然而一压测发现，性能竟然急剧下降了？!

为了分析原因，我们加上JVM 参数jdk.tracePinnedThreads，当线程在block下发生阻塞时会触发堆栈跟踪

  • full 为打印完整的堆栈跟踪，突出显示 native 堆栈帧和持有监视器的堆栈帧
  • short 为输出限制为仅出现问题的堆栈帧
-Djdk.tracePinnedThreads=full

当线程在固定状态下发生阻塞时，会发出JDK Flight Recorder (JFR)事件（请参阅Java Flight Record 详解）

block 线程详细堆栈：

Thread[#57,ForkJoinPool-1-worker-2,5,CarrierThreads]
    java.base/java.lang.VirtualThread$VThreadContinuation.onPinned(VirtualThread.java:185)
    java.base/jdk.internal.vm.Continuation.onPinned0(Continuation.java:393)
    java.base/java.lang.VirtualThread.park(VirtualThread.java:592)
    java.base/java.lang.System$2.parkVirtualThread(System.java:2639)
    java.base/jdk.internal.misc.VirtualThreads.park(VirtualThreads.java:54)
    java.base/java.util.concurrent.locks.LockSupport.park(LockSupport.java:369)
    java.base/sun.nio.ch.Poller$Request.awaitFinish(Poller.java:215)
    java.base/sun.nio.ch.Poller.pollIndirect(Poller.java:143)
    java.base/sun.nio.ch.Poller.poll(Poller.java:102)
    java.base/sun.nio.ch.Poller.poll(Poller.java:89)
    java.base/sun.nio.ch.NioSocketImpl.park(NioSocketImpl.java:175)
    java.base/sun.nio.ch.NioSocketImpl.timedFinishConnect(NioSocketImpl.java:548)
    java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:592)
    java.base/java.net.SocksSocketImpl.connect(SocksSocketImpl.java:327)
    java.base/java.net.Socket.connect(Socket.java:751)
    java.base/sun.security.ssl.SSLSocketImpl.connect(SSLSocketImpl.java:304)
    java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
    java.base/java.lang.reflect.Method.invoke(Method.java:580)
    org.apache.commons.httpclient.protocol.ReflectionSocketFactory.createSocket(ReflectionSocketFactory.java:140)
    org.apache.commons.httpclient.protocol.SSLProtocolSocketFactory.createSocket(SSLProtocolSocketFactory.java:130)
    org.apache.commons.httpclient.HttpConnection.open(HttpConnection.java:707)
    org.apache.commons.httpclient.MultiThreadedHttpConnectionManager$HttpConnectionAdapter.open(MultiThreadedHttpConnectionManager.java:1361)
    org.apache.commons.httpclient.HttpMethodDirector.executeWithRetry(HttpMethodDirector.java:387)
    org.apache.commons.httpclient.HttpMethodDirector.executeMethod(HttpMethodDirector.java:171)
    org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:397)
    org.apache.commons.httpclient.HttpClient.executeMethod(HttpClient.java:323)
    net.oauth.client.httpclient3.HttpClient3.executeOnce(HttpClient3.java:149)
    net.oauth.client.httpclient3.HttpClient3.execute(HttpClient3.java:90)
    net.oauth.client.OAuthClient.access(OAuthClient.java:325)
    net.oauth.client.OAuthClient.invoke(OAuthClient.java:306)
    net.oauth.client.OAuthClient.invoke(OAuthClient.java:262)
    com.test.auth.TestSync.test(TestSync.java:120) <== monitors:1

TestSync是依赖其他业务的 jar 包，堆栈中的monitors:1可见方法获取了监视器锁，即进入了synchronized方法。该synchronized方法里执行了I/O操作。

见虚拟线程官方文档，在两种情况下，虚拟线程在阻塞操作期间无法卸载，因为它绑定了载体线程：

  1. 当它在synchronized块 或 synchronized方法内执行代码
  2. 当执行native方法 或 外部函数

也就是说，TestSync 类中 test 方法是synchronized方法，在方法里执行了较耗时的 I/O 操作，导致 JVM 无法把虚拟线程从平台线程中卸载，使得虚拟线程及其载体线程都被阻塞了，最终导致 Tomcat 容器中无平台线程来执行其他操作

synchronized test {
  // I/O操作
}

原理分析

那究竟是为什么 Project Loom 中，synchronized为什么会导致虚拟线程不能卸载，从而导致虚拟线程及其载体线程都被阻塞了呢？

在当前的Java平台中，synchronized 关键字在底层是通过 Java 对象监视器实现的，其使用的是操作系统线程(OS Thread)。而在 Project Loom 中，为了实现轻量级的并发操作，引入了虚拟线程(virtual threads)的概念，也称为纤程(fibers)。虚拟线程是基于协程(coroutine)的概念，在VM层面上进行管理，而不是依赖于操作系统线程。

为了实现这种轻量级的并发，synchronized关键字需要绑定到操作系统线程(OS Thread)。每个虚拟线程都会被映射到一个操作系统线程，这样可以避免虚拟线程之间的锁竞争和资源争用。

public static void main(String[] args){
	ReentrantLock lock = new ReentrantLock();
	Thread.startVirtualThread(() -> {
	    lock.lock();    
	});
	// 确保锁已经被上面的虚拟线程持有
	Thread.sleep(1000);  
	Thread.startVirtualThread(() -> {
	    System.out.println("first");
	    // 会触发Continuation的yield操作
	    lock.lock(); 
	    try {
	        System.out.println("second");
	    } finally {
	        lock.unlock();
	    }
	    System.out.println("third");
	});
	Thread.sleep(Long.MAX_VALUE);
}

虚拟线程中任务执行时候调用Continuation#run()先执行了部分任务代码，然后尝试获取锁，该操作是阻塞操作会导致 Continuation 的 yield 操作让出控制权

  • 如果 yield 操作成功，会从载体线程 unmount，载体线程栈数据会移动到 Continuation 栈的数据帧中，保存在堆内存中，虚拟线程任务完成，此时虚拟线程和 Continuation 还没有终结和释放，载体线程被释放到执行器中等待新的任务；
  • 如果 Continuation 的 yield 操作失败，则会对载体线程进行 park 调用，阻塞在载体线程上，此时虚拟线程和载体线程同时会被阻塞

会导致 yield 失败的为上面所述的在synchronized块 或 synchronized方法、native方法 或 外部函数


由此可见，在高并发的情况下，许多虚拟线程都挂载到了平台线程，进入了synchronized方法，会导致Continuation的yield操作失败，则会对作为载体的平台线程进行park调用，阻塞在载体线程上，此时虚拟线程和平台线程同时会被阻塞

所以在JEPS 444中，官方推荐使用 ReentrantLock 来替换频繁调用的synchronized块 或 synchronized方法。对于使用不频繁（如启动时使用）的synchronized，可以无需替换。

阻塞/死锁案例

阻塞案例 MySQL JDBC

在这里插入图片描述

相关链接：Contribution: Replace synchronized with ReentrantLock

产生原因：堆栈中的monitors:1可见方法获取了监视器锁，即进入了synchronized方法

官方解决方案：预计Connector/J 9.0.0版本修复，使用ReentrantLock 来替换 synchronized 方法

死锁案例 opentelemetry

相关链接：Posible deadlock with Java 21 Virtual Threads

产生原因：Java OpenTelemetry Agent在处理虚拟线程时，将载体线程置于不一致的状态，从而引发了死锁问题

官方解决方案：Fix virtual thread instrumentation for jdk 21 ea versions

死锁案例 tracePinnedThreads

相关链接：Running with -Djdk.tracePinnedThreads set can hang

产生原因：-Djdk.tracePinnedThreads使用了synchronized方法，会导致虚拟线程无法卸载

官方解决方案：JDK 21.0.4版本修复，使用ReentrantLock 来替换 synchronized 方法

参考资料：

  1. 虚拟线程官方文档
  2. 虚拟线程原理及性能分析
  3. parallelStream/ForkJoinPool 详解
若明天不见
关注
  • 52
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程中使用synchronized说明
12-22
1.在类中方法上加上 　　synchronized关键字，是对整个对象加锁，当一个线程访问带有synchronized的方法时，其他带有synchronized的方法的访问都会阻塞。 　　样例：   public class ThreadTest { public static void main(String[] args) { Stu stu = new Stu(); StuThread1 t1 = new StuThread1(stu); t1.start(); StuThread2 t2 = new StuTh
JDK21虚拟线程详解.pptx.pptx
12-18
虚拟线程的特性 JDK21的虚拟线程，不需要操作系统的原生支持，可以在没有物理机的情况下运行，极大地降低了线程的创建和管理开销。 普通线程的实现方式 普通线程需要操作系统的原生支持，它的创建和管理都需要消耗一定的系统资源，包括内存和CPU等，但稳定性和兼容性较好。 虚拟线程与普通线程的效率对比 虚拟线程在没有物理机的情况下运行，效率可能略低于普通线程，但在大规模并发处理中，由于其轻量级特性，可以大幅度提高程序的运行效率。
ForkJoin详解
BASK2311的博客
05-16 192
Fork/Join框架是Java 7提供的一种用于并行执行任务的框架，它将大任务分解为若干个小任务,并行执行这些小任务，最终通过合并每个小任务的结果得到大任务的结果。Fork/Join采用的是分而治之的基本思想，分而治之就是将一个复杂的任务，按照规定的阈值划分成多个简单的小任务，然后将这些小任务的结果再进行汇总返回，得到最终的任务。欢迎关注个人公众号【好好学技术】交流学习必须首先创建一个ForkJoinTask对象。在分发任务时，需要注意线程安全问题，防止多个线程同时访问共享资源。
虚拟线程详解
最新发布
正在努力~
02-17 988
一文带你快速了解虚拟线程
JDK19 - Virtual Thread 虚拟线程探究
Zong_0915的博客
07-17 1111
先说下我们一般JDK8开发过程中使用到的线程，这部分线程我们称之为平台线程（为的就是和虚拟线程做区分）。平台线程在底层操作系统线程上运行Java代码，并在代码的整个生命周期中捕获操作系统线程。但是在JDK19当中的虚拟线程，他们则是用户模式线程。即由应用程序自己实现和管理的，而不是由操作系统内核实现和管理。
Java 19新特性：虚拟线程(Virtual Threads )
XiumingLee的博客
09-11 5786
JDK19马上就要发布了，今天我们来谈一谈JDK 19的新特性虚线程，它属于JEP 425 Project Loom(425:)。这可能是JDK 19中最值得期待的预览特性之一。我们知道Java阻塞平台线程的代价很高，这就是为什么要不惜一切代价避免这种情况，以及为什么要基于回调编写响应式代码。响应式代码做得很好，但它使代码难以阅读和测试，这显然不是理想的情况。使用DK9和虚拟线程，阻塞线程变得如此廉价，以至于我们不再需要编写响应式代码，我们 的老式阻塞同步代码也可以很好地工作！
线程并发学习----线程阻塞（synchronized）
eos2009的博客
11-28 5503
线程并发学习线程并发学习—-核心概念（转载） 线程并发学习—-线程阻塞（sleep、wait、notifyAll、notify） 线程并发学习—-线程阻塞（synchronized） 线程并发学习—-线程阻塞（concurrent包） 线程并发学习—-Thread、Runnable、Callable spring学习—-线程池 简介在并发编程中，我们需要处理两个关键问题：线程之间如何通信及
Synchronized关键字使用不合理，导致的多线程下线程阻塞问题排查
smart_an的专栏
11-07 176
在为客户进行性能诊断调优时，碰到了一个Synchronized关键字使用不合理导致多线程下线程阻塞的情况。用文字记录下了问题的整个发现-排查-分析-优化过程，排查过程中使用了商业化产品——XLand性能分析平台，通过文章主要希望跟大家分享下分析和优化思路以及注意点，有兴趣深入了解的同学可以评论交流。
高并发之synchronized
hao_yunfeng的博客
09-04 448
synchronized原理 在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。 当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了“obj这个对象”的同步锁。 不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/...
JDK19 - 虚拟线程详解
Zong_0915的博客
08-03 1045
之前在Virtual Thread 虚拟线程探究这篇文章里面主要讲了一下虚拟线程的使用和简要的介绍。这篇文章我们就来深入学习一下相关的原理。：一种提供执行和暂停函数的服务类。Scheduler：执行器。负责将虚拟线程挂载到平台线程上。底层交给执行。其实对上面的流程进行一个简要的总结就是。针对run()先进行装载。把实例和运载线程进行绑定。判断是否存在堆栈内存空间，若存在，说明之前已经执行过一部分调用栈了。那么继续执行（倘若执行过调用栈，那么会把相关数据信息存储到堆内存中）。
Android多线程之同步锁的使用
01-04
本文主要介绍了Android多线程之同步锁的使用，分享给大家，具体如下： 一、同步机制关键字synchronized 对于Java来说，最常用的同步机制就是synchronized关键字，他是一种基于语言的粗略锁，能够作用于对象、函数...
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
java多线程
12-22
多线程由一个或者多个线程组成的程序就是多线程，Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置启动新的线程。二、线程的基本操作2.1 创建创建线程的两种方法1、继承java.lang.Thread上述...
java—多线程的通信、生产者与消费者模式
12-21
run方法是不能用synchronized修饰，他是继承来的，不能改变其结构，而且，如果run方法加了synchronized，就变成单线程了，就没有并发了。 只要不是静态的同步方法，同步方法默认的同步监视器就是this。 静态的同步...
java并发编程：线程基础
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程的创建和管理，以及线程间通信的基本方法。通过深入学习，您将建立扎实的多线程编程基础，能够更好地理解和应用多线程编程。 多...
Java-并发-线程通信详解和案例演示
12-22
  多个线程并发执行时,在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行,那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。...
android实现多线程下载文件（支持暂停、取消、断点续传）
01-05
多线程下载文件（支持暂停、取消、断点续传） 多线程同时下载文件即：在同一时间内通过多个线程对同一个请求地址发起多个请求，将需要下载的数据分割成多个部分，同时下载，每个线程只负责下载其中的一部分，最后将...
详解iOS 多线程 锁 互斥 同步
01-05
在iOS中有几种方法来解决多线程访问同一个内存地址的互斥同步问题： 方法一，@synchronized(id anObject),(最简单的方法) 会自动对参数对象加锁，保证临界区内的代码线程安全 @synchronized(self) { // 这段...
100道多线程面试题,和面试官扯皮没问题了！
01-20
目前Java的面试中，可以说多线程是必问的。在我们学习Java时，这也是非常重要的一个部分。以下给大家分享了100道多线程相关面试题，不打没有准备的战。加油！ 文章目录1.什么是进程?2.什么是线程？3.线程的实现方式?...
java多线程与高并发
05-19
Java多线程和高并发是Java中非常重要的概念和技术，它们可以让Java程序更加高效地利用计算机多核CPU的性能，提升程序的并发能力，提高程序的性能和响应速度。 Java的多线程机制是基于线程对象的，它允许程序同时执行多个任务，从而提高程序的并发能力。Java中的线程有两种创建方式：继承Thread类和实现Runnable接口。其中继承Thread类是比较简单的一种方式，但是它会限制程序的扩展性和灵活性，因为Java只支持单继承。而实现Runnable接口则更加灵活，因为Java支持多实现。 Java的高并发编程主要包括以下几个方面： 1. 线程池技术：线程池技术是Java中非常重要的高并发编程技术，它可以实现线程的复用，减少线程创建和销毁的开销，提高程序的性能和响应速度。 2. 锁机制：Java中的锁机制包括synchronized关键字、ReentrantLock锁、ReadWriteLock读写锁等，它们可以保证多个线程之间的互斥访问，避免数据竞争和线程安全问题。 3. CAS操作：CAS（Compare and Swap）操作是Java中一种非常高效的并发编程技术，它可以实现无锁并发访问，避免线程之间的互斥和阻塞，提高程序的性能和响应速度。 4. 并发集合类：Java中的并发集合类包括ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList等，它们可以实现线程安全的数据访问和操作，有效地提高程序的并发能力。 总之，Java多线程和高并发是Java编程中非常重要的概念和技术，掌握这些技术可以让Java程序更加高效地利用计算机多核CPU的性能，提升程序的并发能力，提高程序的性能和响应速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值