java并发编程 Atomic、CAS和AQS的介绍

于 2025-03-20 15:54:01 发布
阅读量987 收藏 26
点赞数 28
分类专栏： 多线程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38041439/article/details/146398924
版权

Java并发编程进阶：深度剖析Atomic、CAS与AQS实现原理

引言：现代并发编程的基石

在多核处理器时代，高效并发控制是提升系统性能的关键。Java并发包（JUC）中的三大核心技术——Atomic原子类、CAS机制和AQS框架，构成了现代并发编程的基础设施。本文将通过原理剖析、源码解读和实战案例，带你深入理解这些核心技术的实现机制。

一、核心概念全景解析

1.1 Atomic原子类体系

实现原理：

Atomic类实现
CAS原子操作
Unsafe类
volatile变量
内存屏障

类继承体系：

  • 基础类型：AtomicInteger/AtomicLong/AtomicBoolean
  • 引用类型：AtomicReference/AtomicStampedReference
  • 数组类型：AtomicIntegerArray/AtomicLongArray
  • 字段更新：AtomicIntegerFieldUpdater

内存可见性保障：

// AtomicInteger源码片段
public class AtomicInteger extends Number {
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private volatile int value; // volatile保证可见性
    
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
}

1.2 CAS机制深度探秘

CPU指令级实现：

  • x86架构：CMPXCHG指令
  • ARM架构：LL/SC指令对

ABA问题解决方案：

// 使用AtomicStampedReference解决ABA问题
AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

int[] stampHolder = new int[1];
String current = ref.get(stampHolder);
ref.compareAndSet(current, "B", stampHolder[0], stampHolder[0]+1);

CAS性能优化策略：

  1. 自适应自旋（JVM实现）
  2. 批量操作（LongAdder的分段统计）
  3. 退避策略（指数退避算法）

1.3 AQS框架设计

CLH队列实现：

CLH队列
Thread1 Node
Head
Thread2 Node
Thread3 Node
Tail

状态管理机制：

  • 同步状态（state）：volatile int类型
  • 节点状态（waitStatus）：
    • CANCELLED(1)
    • SIGNAL(-1)
    • CONDITION(-2)
    • PROPAGATE(-3)

二、关键技术实现剖析

2.1 Atomic原子类高效实现

缓存行优化：

// LongAdder的Cell类使用@Contended避免伪共享
@sun.misc.Contended 
static final class Cell {
    volatile long value;
    // ...
}

分段计数原理：

LongAdder
竞争时
竞争时
竞争时
Cell1
Base值
Cell2
Cell3

2.2 AQS实现可重入锁

ReentrantLock类结构：

public class ReentrantLock implements Lock {
    private final Sync sync; // 继承自AQS
    
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 实现tryAcquire等模板方法
    }
}

获取锁流程：

Thread AQS CLH_Queue acquire(1) tryAcquire(1) 返回 addWaiter(Node.EXCLUSIVE) 返回节点 acquireQueued(node, arg) alt [获取成功] [获取失败] Thread AQS CLH_Queue

三、实战开发案例集

3.1 CAS 实战代码

ABA 问题解决方案
使用版本号（AtomicStampedReference）
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABASolutionWithStamp {
    public static void main(String[] args) {
        // 使用 AtomicStampedReference 解决 ABA 问题
        AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);

        int[] stampHolder = new int[1];
        String current = ref.get(stampHolder);

        // 模拟 ABA 操作
        ref.compareAndSet(current, "B", stampHolder[0], stampHolder[0] + 1);
        ref.compareAndSet("B", "A", stampHolder[0] + 1, stampHolder[0] + 2);

        // 再次尝试更新
        if (ref.compareAndSet(current, "C", stampHolder[0], stampHolder[0] + 1)) {
            System.out.println("更新成功");
        } else {
            System.out.println("更新失败，可能发生了 ABA 问题");
        }
    }
}
使用 AtomicMarkableReference
import java.util.concurrent.atomic.AtomicMarkableReference;

public class ABASolutionWithMark {
    public static void main(String[] args) {
        // 使用 AtomicMarkableReference 解决 ABA 问题
        AtomicMarkableReference<String> ref = new AtomicMarkableReference<>("A", false);

        boolean[] markHolder = new boolean[1];
        String current = ref.get(markHolder);

        // 模拟 ABA 操作
        ref.compareAndSet(current, "B", markHolder[0], !markHolder[0]);
        ref.compareAndSet("B", "A", !markHolder[0], markHolder[0]);

        // 再次尝试更新
        if (ref.compareAndSet(current, "C", markHolder[0], !markHolder[0])) {
            System.out.println("更新成功");
        } else {
            System.out.println("更新失败，可能发生了 ABA 问题");
        }
    }
}
CAS 性能优化策略
自适应自旋（JVM 实现）

JVM 会根据当前系统的状态自动调整自旋的次数，避免长时间的自旋消耗过多的 CPU 资源。以下是一个简单的示例，模拟自适应自旋的效果：

import java.util.concurrent.atomic.AtomicInteger;

public class AdaptiveSpinExample {
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                int expect = counter.get();
                if (counter.compareAndSet(expect, expect + 1)) {
                    System.out.println("线程 1 更新成功，当前值: " + counter.get());
                    break;
                }
                // 模拟自适应自旋，可根据实际情况调整自旋次数
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            while (true) {
                int expect = counter.get();
                if (counter.compareAndSet(expect, expect + 1)) {
                    System.out.println("线程 2 更新成功，当前值: " + counter.get());
                    break;
                }
                // 模拟自适应自旋，可根据实际情况调整自旋次数
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
批量操作（LongAdder 的分段统计）
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.LongAdder;

public class LongAdderExample {
    public static void main(String[] args) throws InterruptedException {
        LongAdder adder = new LongAdder();
        ExecutorService executor = Executors.newFixedThreadPool(10);

        // 模拟多线程并发增加操作
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                adder.increment();
            });
        }

        executor.shutdown();
        while (!executor.isTerminated()) {
            // 等待所有任务完成
        }

        System.out.println("最终结果: " + adder.sum());
    }
}
退避策略（指数退避算法）
import java.util.concurrent.ThreadLocalRandom;

class Backoff {
    final int minDelay, maxDelay;
    int limit;

    public Backoff(int minDelay, int maxDelay) {
        this.minDelay = minDelay;
        this.maxDelay = maxDelay;
        this.limit = minDelay;
    }

    public void backoff() throws InterruptedException {
        int delay = ThreadLocalRandom.current().nextInt(limit);
        limit = Math.min(maxDelay, limit * 2);
        Thread.sleep(delay);
    }
}

public class BackoffExample {
    private static final int MIN_DELAY = 1;
    private static final int MAX_DELAY = 100;
    private static final int ATTEMPTS = 10;

    public static void main(String[] args) {
        Backoff backoff = new Backoff(MIN_DELAY, MAX_DELAY);

        for (int i = 0; i < ATTEMPTS; i++) {
            try {
                // 模拟 CAS 操作失败
                if (!simulateCAS()) {
                    System.out.println("CAS 操作失败，尝试退避...");
                    backoff.backoff();
                } else {
                    System.out.println("CAS 操作成功");
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static boolean simulateCAS() {
        // 模拟 CAS 操作失败的概率
        return Math.random() > 0.5;
    }
}

通过以上内容，我们对原文档中的 CAS 实践进行了完善，涵盖了更多的 ABA 问题解决方案和 CAS 性能优化策略，并提供了相应的代码示例。

3.2 高性能无锁队列

自定义信号量实现

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

// 自定义信号量类
class CustomSemaphore {
    private final Sync sync;

    // 构造函数，初始化信号量许可数量
    public CustomSemaphore(int permits) {
        sync = new Sync(permits);
    }

    // 获取许可
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 释放许可
    public void release() {
        sync.releaseShared(1);
    }

    // 内部同步器类，继承自 AQS
    private static final class Sync extends AbstractQueuedSynchronizer {
        Sync(int permits) {
            setState(permits);
        }

        // 获取共享资源
        @Override
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 || compareAndSetState(available, remaining)) {
                    return remaining;
                }
            }
        }

        // 释放共享资源
        @Override
        protected boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (compareAndSetState(current, next)) {
                    return true;
                }
            }
        }
    }
}

自定义可重入读写锁实现

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

// 自定义可重入读写锁类
class CustomReadWriteLock {
    private final Sync sync = new Sync();

    // 获取读锁
    public void readLock() {
        sync.acquireShared(1);
    }

    // 释放读锁
    public void readUnlock() {
        sync.releaseShared(1);
    }

    // 获取写锁
    public void writeLock() {
        sync.acquire(1);
    }

    // 释放写锁
    public void writeUnlock() {
        sync.release(1);
    }

    // 内部同步器类，继承自 AQS
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final int SHARED_SHIFT = 16;
        private static final int SHARED_UNIT = (1 << SHARED_SHIFT);
        private static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
        private static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

        // 获取共享计数
        static int sharedCount(int c) {
            return c >>> SHARED_SHIFT;
        }

        // 获取独占计数
        static int exclusiveCount(int c) {
            return c & EXCLUSIVE_MASK;
        }

        // 尝试获取共享资源
        @Override
        protected int tryAcquireShared(int unused) {
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) {
                return -1;
            }
            int r = sharedCount(c);
            if (!compareAndSetState(c, c + SHARED_UNIT)) {
                return -1;
            }
            if (r == 0) {
                setExclusiveOwnerThread(null);
            }
            return 1;
        }

        // 尝试释放共享资源
        @Override
        protected boolean tryReleaseShared(int unused) {
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;
                if (compareAndSetState(c, nextc)) {
                    return nextc == 0;
                }
            }
        }

        // 尝试获取独占资源
        @Override
        protected boolean tryAcquire(int acquires) {
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) {
                if (w == 0 || current != getExclusiveOwnerThread()) {
                    return false;
                }
                if (w + exclusiveCount(acquires) > MAX_COUNT) {
                    throw new Error("Maximum lock count exceeded");
                }
                setState(c + acquires);
                return true;
            }
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
            return false;
        }

        // 尝试释放独占资源
        @Override
        protected boolean tryRelease(int releases) {
            if (!isHeldExclusively()) {
                throw new IllegalMonitorStateException();
            }
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            if (free) {
                setExclusiveOwnerThread(null);
            }
            setState(nextc);
            return free;
        }

        // 判断是否为当前线程独占
        @Override
        protected boolean isHeldExclusively() {
            return getExclusiveOwnerThread() == Thread.currentThread();
        }
    }
}

测试代码

public class AQSPracticeTest {
    public static void main(String[] args) {
        // 测试自定义信号量
        CustomSemaphore semaphore = new CustomSemaphore(2);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " acquired permit");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                    System.out.println(Thread.currentThread().getName() + " released permit");
                }
            }).start();
        }

        // 测试自定义可重入读写锁
        CustomReadWriteLock readWriteLock = new CustomReadWriteLock();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                readWriteLock.readLock();
                try {
                    System.out.println(Thread.currentThread().getName() + " acquired read lock");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    readWriteLock.readUnlock();
                    System.out.println(Thread.currentThread().getName() + " released read lock");
                }
            }).start();
        }

        new Thread(() -> {
            readWriteLock.writeLock();
            try {
                System.out.println(Thread.currentThread().getName() + " acquired write lock");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readWriteLock.writeUnlock();
                System.out.println(Thread.currentThread().getName() + " released write lock");
            }
        }).start();
    }
}

代码解释

  1. 自定义信号量：

    • CustomSemaphore 类使用 Sync 内部类继承自 AbstractQueuedSynchronizer 来实现信号量的功能。
    • acquire 方法用于获取许可，release 方法用于释放许可。
    • tryAcquireShared 和 tryReleaseShared 方法分别实现了获取和释放共享资源的逻辑。

  2. 自定义可重入读写锁：

    • CustomReadWriteLock 类使用 Sync 内部类继承自 AbstractQueuedSynchronizer 来实现可重入读写锁的功能。
    • readLock 和 readUnlock 方法用于获取和释放读锁，writeLock 和 writeUnlock 方法用于获取和释放写锁。
    • tryAcquireShared、tryReleaseShared、tryAcquire 和 tryRelease 方法分别实现了获取和释放共享资源、独占资源的逻辑。

  3. 测试代码：

    • 创建了一个自定义信号量和一个自定义可重入读写锁，并启动多个线程来测试它们的功能。

4.2 常见问题解决方案

场景：高竞争环境下的性能瓶颈
方案：

  1. 使用LongAdder替代AtomicLong
  2. 增加锁分离（如ConcurrentHashMap的分段锁）
  3. 采用无锁数据结构

场景：线程饥饿问题
方案：

// 公平锁实现
public class FairLock extends AbstractQueuedSynchronizer {
    protected final boolean tryAcquire(int acquires) {
        if (!hasQueuedPredecessors() && 
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
}

五、架构演进与未来展望

5.1 Java并发模型演进

timeline
    title Java并发模型发展史
    section JDK1.5
        JUC包诞生 : AQS/CAS/Atomic
    section JDK1.7
        Fork/Join框架 : 工作窃取算法
    section JDK1.8
        CompletableFuture : 异步编程
        StampedLock : 乐观读锁
    section JDK19+
        虚拟线程 : Project Loom

5.2 新一代并发编程模式

  1. 反应式编程：Project Reactor
  2. 协程支持：Virtual Thread
  3. 无锁算法：RCU（Read-Copy-Update）
Java并发编程-AQS详解及案例实战（上篇）
program哲学
07-06 481
详细介绍AQS底层机制及相关应用案例实战
java cas 和AQS
Meiko记录
06-29 1032
什么是CAS机制 CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。 CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。 更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。 CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。 CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。 更新一个变量的时候，只有当变量的预期值A和内存地址
深入理解Java中的AQS
weixin_30472035的博客
07-31 210
AQS概述 ​ AbstractQueuedSynchronizer抽象队列同步器简称AQS，它是实现同步器的基础组件，juc下面Lock的实现以及一些并发工具类就是通过AQS来实现的，这里我们通过AQS的类图先看一下大概，下面我们总结一下AQS的实现原理。先看看AQS的类图。 ​ (1)AQS是一个通过内置的FIFO双向队列来完成线程的排队工作(内部通过结点head和tail记录队首...
Java中的锁[原理、锁优化、CAS、AQS]
高广超的博客
03-30 929
本文作者：景小财 作者简介：美团外卖活动业务负责人 1、为什么要用锁？ 锁-是为了解决并发操作引起的脏读、数据不一致的问题。 2、锁实现的基本原理 2.1、volatile Java编程语言允许线程访问共享变量， 为了确保共享变量能被准确和一致地更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁要更加方...
【Java并发编程】AQS和CAS
weixin_44735928的博客
08-18 1377
AQS和CAS
JAVA集合框架、CAS、AQS
梭哈是一种智慧
07-07 1203
java 的集合框架有哪些 ? 、CAS机制、AQS机制
并发编程核心技术揭秘：CAS和AQS详解与应用案例
逆流的小鱼
05-31 423
AbstractQueuedSynchronizer（AQS）是实现依赖于先进先出（FIFO）等待队列的同步器的框架。它为多个同步器提供了一个可重用的基础，如ReentrantLock、Semaphores、CountDownLatch等。AQS使用一个int类型的成员变量表示同步状态（state），并通过内置的FIFO队列来管理线程。同步状态（State）：表示资源的占用情况。节点（Node）：构成等待队列，存储线程信息。内置FIFO队列：管理因获取状态失败而等待的线程。
Java 面试中常见的 CAS 和 AQS 问题解析
最新发布
道长的博客
07-11 695
在 Java 面试中，CAS（Compare and Swap，比较并交换）和AQS（AbstractQueuedSynchronizer，抽象队列同步器）是经常被问到的重要知识点。下面为大家整理了一些常见的面试题及详细解析。
Java~并发编程CAS和AQS原理刨析，东软java面试题
weixin_57992300的博客
03-18 1118
if (!} else {
Java并发编程全景图.pdf
02-09
为了深入理解Java并发编程，有必要了解其核心技术点和相关实现原理，以下将详细介绍文件中提及的关键知识点。 1. Java同步原语 Java提供了多种同步原语来保证线程安全，主要包括关键字volatile、synchronized以及...
Java~并发编程CAS和AQS原理刨析，阿里大牛纯手码7W字
m0_60453176的博客
03-30 751
/ 设置值为 newValue//返回旧值，并设置新值为　newValue/**这里使用for循环不断通过CAS操作来设置新值CAS实现和加锁实现的关系有点类似乐观锁和悲观锁的关系*/for (;😉 {// 原子的设置新值为update, expect为期望的当前的值//本质上还是使用unsafe的native方法实现的, 就是硬件的原子操作帮助实现CAS// 获取当前值current，并设置新值为current+1for (;😉 {
Java锁事之Unsafe、CAS、AQS知识点总结
吴就业
02-13 595
Unsafe、CAS、AQS是我们了解Java中除synchronized之外的锁必须要掌握的重要知识点。CAS是一个比较和替换的原子操作，AQS的实现...
什么是CAS，什么是AQS，两者到底有什么区别
yztezhl的专栏
12-29 1379
CAS是指 Compare and Swap（比较并交换）操作，它是一种并发编程中的原子操作，通常用于多线程环境下实现同步和线程安全。CAS包括三个值：v表示要更新的变量e表示预期值，就是旧的值n表示新值更新时，判断只有e的值等于v变量的当前旧值时，才会将n新值赋给v，更新为新值。否则，则认为已经有其他线程更新过了，则当前线程什么都不操作，最后cas放回当前v变量的真实值。如下图：看到这里，大家对CAS原理了解了。但是会有个疑问一直听说有个CAS,但没用过。
Java的atomic包下的CAS原子操作类原理
weixin_44715716的博客
09-23 574
java并发编程的CAS
java atomic cas_java中的CAS和原子类的实现（JDK1.8）
weixin_34677379的博客
02-13 160
什么是CASCAS的全称为Compare-And-Swap，直译就是对比交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说CAS是靠硬件实现的，JVM只是封装了汇编调用，那些AtomicInteger类便是使用了这些封装后的接口。简单解释：CAS操作需要输入两个数值，一个旧值(期望操作前的值)...
java atomic cas_Java CAS及其应用(自旋锁 Atomic类)
weixin_42298081的博客
02-13 222
一、CAS 操作乐观锁用到的机制就是CAS，Compare and Swap。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。1、非阻塞算法 (nonblocking algorithms)一个线程的失败或者挂起不应该影响其他线程的失败或挂起的算法。现代的CPU提供了特殊的指令，可以自动更新共享数据，而且能够检测到其...
Java并发之AQS详解
weixin_34387468的博客
10-29 749
一、概述 　　谈到并发，不得不谈ReentrantLock；而谈到ReentrantLock，不得不谈AbstractQueuedSynchronizer（AQS）！ 　　类如其名，抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch...。 　　以下是本文的目录大...
JAVA CAS原理以及应用atomic
yayaqwl的博客
08-21 295
官方说法： 提到CAS，就会想到悲观锁，乐观锁。 CAS是乐观锁。 CAS,compare and swap的缩写，中文翻译成比较并交换。 独占锁是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观...
Java并发工具包AQS、Lock、CountDownLatch实例解析
以上内容详细介绍了JUC并发工具包实例.zip压缩包中可能涉及的核心知识点，希望能够为学习Java并发编程的开发者提供参考和帮助。由于并发编程的复杂性，理解这些知识点将有助于更好地利用Java提供的并发工具包解决...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stayhungerstayflush

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值