Phaser详解

最新推荐文章于 2024-09-05 10:15:00 发布
最新推荐文章于 2024-09-05 10:15:00 发布
阅读量943 收藏 2
点赞数
分类专栏： 并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44906791/article/details/130497211
版权
Phaser是Java中的一个并发工具，允许程序灵活控制多线程的执行顺序和阶段。它可以动态调整参与任务的数量，适用于批量数据处理和模拟并发场景。文章通过示例展示了如何使用Phaser进行任务分发和阶段同步，以及在伙伴出游的模拟中如何实现线程间的协作和退出条件判断。
摘要由CSDN通过智能技术生成

文章目录

前言

Phaser（阶段协同器）是一个Java实现的并发工具类，用于协调多个线程的执行。它提供了一些方便的方法来管理多个阶段的执行，可以让程序员灵活地控制线程的执行顺序和阶段性的执行。Phaser可以被视为CyclicBarrier和CountDownLatch的进化版，它能够自适应地调整并发线程数，可以动态地增加或减少参与线程的数量。所以Phaser特别适合使用在重复执行或者重用的情况。
在这里插入图片描述

常用API

构造方法

  • Phaser(): 参与任务数0
  • Phaser(int parties) :指定初始参与任务数
  • Phaser(Phaser parent) :指定parent阶段器， 子对象作为一个整体加入parent对象， 当子对象中没有参与者时，会自动从parent对象解除注册
  • Phaser(Phaser parent，int parties) : 集合上面两个方法

增减参与任务数方法

  • int register() 增加一个任务数，返回当前阶段号。
  • int bulkRegister(int parties) 增加指定任务个数，返回当前阶段号。
  • int arriveAndDeregister() 减少一个任务数，返回当前阶段号。

到达、等待方法

  • int arrive() 到达(任务完成)，返回当前阶段号。
  • int arriveAndAwaitAdvance() 到达后等待其他任务到达，返回到达阶段号。
  • int awaitAdvance(int phase) 在指定阶段等待(必须是当前阶段才有效)
  • int awaitAdvanceInterruptibly(int phase) 阶段到达触发动作
  • int awaitAdvanceInterruptiBly(int phase，long timeout，TimeUnit unit)
  • protected boolean onAdvance(int phase，int registeredParties)类似CyclicBarrier的触发命令，通过重写该方法来增加阶段到达动作，该方法返回true将终结Phaser对象。

Phaser使用

多线程批量处理数据

public class PhaserBatchProcessorDemo {

    private final List<String> data;
    private final int batchsize;//一次处理多少数据
    private final int threadCount;//处理的线程数
    private final Phaser phaser;
    private final List<String> processedData;

    public PhaserBatchProcessorDemo(List<String> data,int batchsize,int threadCount){
        this.data = data;
        this.batchsize = batchsize;
        this.threadCount = threadCount;
        this.phaser = new Phaser(1);
        //this.phaser = new Phaser();
        this.processedData = new ArrayList<>();
    }

    public void process() throws InterruptedException {
        for(int i = 0;i<threadCount;i++){
            System.out.println("phaser.register():"+phaser.register());
            new Thread(new BatchProcessor(i)).start();
            Thread.sleep(50);
        }
        phaser.arriveAndDeregister();//主线程执行结束
        System.out.println("结束");
    }

    private class BatchProcessor implements Runnable{
        private final int threadIndex;
        public BatchProcessor(int threadIndex){this.threadIndex = threadIndex;}

        @Override
        public void run() {
            int index = 0;
            while(true){
                //所有线程都到达这个点之前会阻塞
                System.out.println("线程"+threadIndex+"phaser.arriveAndAwaitAdvance1():");
                phaser.arriveAndAwaitAdvance();

                //从未处理数据中找到一个可以处理的批次
                List<String> batch = new ArrayList<>();
                synchronized (data){
                    while (index < data.size()&&batch.size()<batchsize){
                        String d = data.get(index);
                        if(!processedData.contains(d)){
                            batch.add(d);
                            processedData.add(d);
                        }
                        index++;
                    }
                }
                //处理数据
                for(String d:batch){
                    System.out.println("线程"+threadIndex+"处理数据"+d);
                }
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //所有数据都处理完当前批次之前会阻塞
                System.out.println("线程"+threadIndex+"phaser.arriveAndAwaitAdvance2():");
                phaser.arriveAndAwaitAdvance();
                //所有线程都处理完当前批次并且未处理数据已经处理完之前会阻塞
                if(batch.isEmpty()||index >= data.size()){
                    System.out.println("线程"+threadIndex+"phaser.arriveAndDeregister()"+phaser.arriveAndDeregister());
                    break;
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        List<String> data = new ArrayList<>();
        for(int i = 1;i<=15;i++){
            data.add(String.valueOf(i));
        }

        PhaserBatchProcessorDemo processor = new PhaserBatchProcessorDemo(data,4,3);
        processor.process();
    }
}

/**
 * phaser.register():0
 * 线程0phaser.arriveAndAwaitAdvance1():
 * phaser.register():0
 * 线程1phaser.arriveAndAwaitAdvance1():
 * phaser.register():0
 * 线程2phaser.arriveAndAwaitAdvance1():
 * 结束
 * 线程2处理数据9
 * 线程2处理数据10
 * 线程1处理数据5
 * 线程1处理数据6
 * 线程1处理数据7
 * 线程1处理数据8
 * 线程2处理数据11
 * 线程2处理数据12
 * 线程0处理数据1
 * 线程0处理数据2
 * 线程0处理数据3
 * 线程0处理数据4
 * 线程2phaser.arriveAndAwaitAdvance2():
 * 线程0phaser.arriveAndAwaitAdvance2():
 * 线程1phaser.arriveAndAwaitAdvance2():
 * 线程2phaser.arriveAndAwaitAdvance1():
 * 线程1phaser.arriveAndAwaitAdvance1():
 * 线程0phaser.arriveAndAwaitAdvance1():
 * 线程0处理数据13
 * 线程0处理数据14
 * 线程0处理数据15
 * 线程0phaser.arriveAndAwaitAdvance2():
 * 线程1phaser.arriveAndAwaitAdvance2():
 * 线程2phaser.arriveAndAwaitAdvance2():
 * 线程1phaser.arriveAndDeregister()4
 * 线程2phaser.arriveAndDeregister()4
 * 线程0phaser.arriveAndDeregister()4
 */

这里提出一个问题：为什么要给主线程也注册呢？如果不给主线程注册会怎么样呢？
在这里插入图片描述
这里就要提及register() 增加任务数量和Phaser()初始化定义任务数量的区别：
register()有一个需要注意的点是，如果主线程执行速度缓慢的话，很有可能在第一个线程已经arrive的时候，第二个线程任务还没增加，导致第一个线程因为parties只有1，而没有阻塞等待就进入下一阶段了。

如果不给主线程注册添加任务，运行结果如下

phaser.register():0
线程0phaser.arriveAndAwaitAdvance1():
线程0处理数据1
线程0处理数据2
线程0处理数据3
线程0处理数据4
phaser.register():1
线程1phaser.arriveAndAwaitAdvance1():
phaser.register():1
线程2phaser.arriveAndAwaitAdvance1():
结束
线程0phaser.arriveAndAwaitAdvance2():
线程0phaser.arriveAndAwaitAdvance1():
线程2处理数据5
线程2处理数据6
线程2处理数据7
线程2处理数据8
线程1处理数据9
线程1处理数据10
线程1处理数据11
线程1处理数据12
线程2phaser.arriveAndAwaitAdvance2():
线程1phaser.arriveAndAwaitAdvance2():
线程2phaser.arriveAndAwaitAdvance1():
线程1phaser.arriveAndAwaitAdvance1():
线程0处理数据13
线程0处理数据14
线程0处理数据15
线程0phaser.arriveAndAwaitAdvance2():
线程0phaser.arriveAndDeregister()4
线程1phaser.arriveAndAwaitAdvance2():
线程2phaser.arriveAndAwaitAdvance2():
线程2phaser.arriveAndDeregister()5
线程1phaser.arriveAndDeregister()5

而Phaser()初始化就定义了parties，会让所有线程都必须到达之前都阻塞才能进入下一阶段。
给主线程也增加一个任务的目的就在于此
如果主线程也有任务，就算主线程执行缓慢，第一个线程也必须阻塞等待主线程在第一阶段之前，把所有线程都start()启动。

阶段性任务：模拟伙伴出游

public class PhaserDemo {
    public static void main(String[] args) {
        final Phaser phaser = new Phaser(){
            @Override
            protected boolean onAdvance(int phase, int registeredParties) {
                //参与者数量，去除主线程
                int persons = registeredParties - 1;
                switch (phase){
                    case 0:
                        System.out.println("大家都到佘山站了，可以出发去佘山了，人数："+persons);
                        break;
                    case 1:
                        System.out.println("大家都到佘山了，出发去爬山，人数："+persons);
                        break;
                    case 2:
                        System.out.println("大家都到山顶了，开始休息，人数："+persons);
                        break;

                }
                //判断是否只剩下一个主线程，如果是，返回true,代表终止
                return registeredParties ==1;
            }
        };

        phaser.register();
        final PersonTask personTask = new PersonTask();
        //3个全程参加的伙伴
        for(int i = 0;i<3;i++){

            phaser.register();
            new Thread(()->{
                try{
                    personTask.step1Task();
                    phaser.arriveAndAwaitAdvance();

                    personTask.step2Task();
                    phaser.arriveAndAwaitAdvance();

                    personTask.step3Task();
                    phaser.arriveAndAwaitAdvance();

                    personTask.step4Task();
                    phaser.arriveAndDeregister();


                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }).start();
        }
        

        //两个在山腰半路返回
        for(int i = 0;i<2;i++){
            phaser.register();
            new Thread(()->{
                try{
                    personTask.step1Task();
                    phaser.arriveAndAwaitAdvance();

                    personTask.step2Task();
                    phaser.arriveAndAwaitAdvance();

                    personTask.step3Task();
                    System.out.println("伙伴【"+Thread.currentThread().getName()+"】中途山腰返回");
                    phaser.arriveAndDeregister();

                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }).start();
        }

        while (!phaser.isTerminated()) {
            int phase = phaser.arriveAndAwaitAdvance();
            if (phase == 2) {
                //两个在佘山直接会合
                for(int i = 0;i<2;i++){
                    phaser.register();
                    new Thread(()->{
                        try{
                            System.out.println("伙伴【"+Thread.currentThread().getName()+"】中途加入");

                            personTask.step3Task();
                            phaser.arriveAndAwaitAdvance();

                            personTask.step4Task();
                            phaser.arriveAndDeregister();

                        }catch (InterruptedException e){
                            e.printStackTrace();
                        }
                    }).start();
                }
            }
        }
    }

    static final Random random = new Random();

    static class PersonTask{
        public void step1Task() throws InterruptedException {
            String person = "伙伴【"+Thread.currentThread().getName()+"】";
            System.out.println(person+"从家出发了......");
            Thread.sleep(random.nextInt(5000));
            System.out.println(person+"到达佘山站");
        }

        public void step2Task() throws InterruptedException {
            String person = "伙伴【"+Thread.currentThread().getName()+"】";
            System.out.println(person+"出发去佘山");
            Thread.sleep(random.nextInt(5000));
            System.out.println(person+"到达佘山");
        }

        public void step3Task() throws InterruptedException {
            String person = "伙伴【"+Thread.currentThread().getName()+"】";
            System.out.println(person+"出发去爬山");
            Thread.sleep(random.nextInt(5000));
            System.out.println(person+"到达山顶");
        }

        public void step4Task() throws InterruptedException {
            String person = "伙伴【"+Thread.currentThread().getName()+"】";
            System.out.println(person+"开始休息");
            Thread.sleep(random.nextInt(5000));
            System.out.println(person+"休息结束，下山回家");
        }
    }
}

/**
 * 伙伴【Thread-3】从家出发了......
 * 伙伴【Thread-1】从家出发了......
 * 伙伴【Thread-2】从家出发了......
 * 伙伴【Thread-4】从家出发了......
 * 伙伴【Thread-0】从家出发了......
 * 伙伴【Thread-1】到达佘山站
 * 伙伴【Thread-4】到达佘山站
 * 伙伴【Thread-3】到达佘山站
 * 伙伴【Thread-0】到达佘山站
 * 伙伴【Thread-2】到达佘山站
 * 大家都到佘山站了，可以出发去佘山了，人数：5
 * 伙伴【Thread-3】出发去佘山
 * 伙伴【Thread-2】出发去佘山
 * 伙伴【Thread-4】出发去佘山
 * 伙伴【Thread-1】出发去佘山
 * 伙伴【Thread-0】出发去佘山
 * 伙伴【Thread-1】到达佘山
 * 伙伴【Thread-4】到达佘山
 * 伙伴【Thread-3】到达佘山
 * 伙伴【Thread-0】到达佘山
 * 伙伴【Thread-2】到达佘山
 * 大家都到佘山了，出发去爬山，人数：5
 * 伙伴【Thread-1】出发去爬山
 * 伙伴【Thread-4】出发去爬山
 * 伙伴【Thread-0】出发去爬山
 * 伙伴【Thread-2】出发去爬山
 * 伙伴【Thread-3】出发去爬山
 * 伙伴【Thread-6】中途加入
 * 伙伴【Thread-6】出发去爬山
 * 伙伴【Thread-5】中途加入
 * 伙伴【Thread-5】出发去爬山
 * 伙伴【Thread-2】到达山顶
 * 伙伴【Thread-5】到达山顶
 * 伙伴【Thread-0】到达山顶
 * 伙伴【Thread-4】到达山顶
 * 伙伴【Thread-4】中途山腰返回
 * 伙伴【Thread-6】到达山顶
 * 伙伴【Thread-3】到达山顶
 * 伙伴【Thread-3】中途山腰返回
 * 伙伴【Thread-1】到达山顶
 * 大家都到山顶了，开始休息，人数：5
 * 伙伴【Thread-5】开始休息
 * 伙伴【Thread-2】开始休息
 * 伙伴【Thread-6】开始休息
 * 伙伴【Thread-0】开始休息
 * 伙伴【Thread-1】开始休息
 * 伙伴【Thread-2】休息结束，下山回家
 * 伙伴【Thread-0】休息结束，下山回家
 * 伙伴【Thread-1】休息结束，下山回家
 * 伙伴【Thread-5】休息结束，下山回家
 * 伙伴【Thread-6】休息结束，下山回家
 */

应用场景总结

以下是一些常见的 Phaser 应用场景：

  1. 多线程任务分配：Phaser 可以用于将复杂的任务分配给多个线程执行，并协调线程间的合作。
  2. 多级任务流程：Phaser 可以用于实现多级任务流程，在每一级任务完成后触发下一级任务的开始。
  3. 模拟并行计算：Phaser 可以用于模拟并行计算，协调多个线程间的工作。
  4. 阶段性任务：Phaser 可以用于实现阶段性任务，在每一阶段任务完成后触发下一阶段任务的开始。
啊几
关注
专栏目录
Phaser api详解
小白爱学习的专栏
07-27 460
今天时间学习Phaserapi，该类是JUC原子包中的类，通过单元测试代码把所有public api方法跑了一遍，大致了解了底层实现，初学乍练，有很多一知半解的地方，待后续有了深入理解再来补充 package test.java.util.concurrent; import java.util.concurrent.Phaser; import java.util.concurrent.TimeUnit; import org.junit.Test; /** * Phaser的测试类 *.
java多线程之Phaser的使用详解
08-19
主要介绍了java多线程之Phaser的使用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java并发编程-Phaser解析
最新发布
WenZhang的博客
09-05 852
在并发编程中，协调多个线程之间的执行顺序是一个常见的需求。Java 提供了多种工具来处理线程同步问题，如和Semaphore。然而，这些工具在某些复杂的场景中显得有些笨拙或受限。为了提供一种更灵活、更强大的阶段性同步机制，Java 并发包引入了Phaser类。Phaser是 Java 7 引入的一个高级同步工具，它允许一组线程在多个阶段上进行同步，而不是像那样只在一个点上进行同步。这使得Phaser在处理多阶段并发任务时特别有用，尤其是在动态调整参与线程数量的情况下。通过Phaser。
Phaser用法详解
.
03-27 901
Phaser用法详解 用Phaser替代CyclicBarrier和CountDownLatch Phaser相比CyclicBarrier和CountDownLatch功能更强大，包括它两的所有功能。 用Phaser替代CyclicBarrier public class PhaserTest1 { public static void main(String[] args) { Phaser phaser = new Phaser(); for (in
JUC 工具类之 Phaser 详解
liuwg1226的专栏
09-12 811
一 概述 Phaser 是 JDK1.7 推出的，一个可重用的同步障碍，与 CyclicBarrier，CountDownLatch 功能类似，但是它支持更灵活的用法。 先简单说明这个类的作用。假设有一个大工程，可以分为多个阶段，每一个阶段有多个人参与，并且每一个阶段需要参与的所有人都完成这个阶段的事情，才可以进入下一个阶段，然后所有人又继续做下一个阶段的事，直到所有阶段都完成，当然这途中每个人都可以随时退出，整个工程也可以中途终止。 二 Phaser 的使用 例如某天陈皮约小美，小雪去他家吃饭。这个事情可
JUC第二十九讲：JUC工具类: Phaser详解
Jet_qi的博客
10-14 278
本文是JUC第二十九讲，JUC工具类：Phaser详解。Phaser是JDK 7新增的一个同步辅助类，它可以实现 CyclicBarrier 和CountDownLatch 类似的功能，而且它支持对任务的动态调整，并支持分层结构来达到更高的吞吐量。
phaser-flappy-bird-clone：具有Phaser和Typescript的Flappy Bird克隆
02-04
《基于Phaser和TypeScript的Flappy Bird克隆游戏详解》 在当今的数字时代，游戏开发已经成为一种流行的艺术和技术结合体。其中，Flappy Bird作为一款曾经风靡全球的简单却又极具挑战性的游戏，吸引了许多开发者进行...
ConnectNumber：Phaser游戏； 在这里玩
02-04
《ConnectNumber：基于Phaser的游戏开发详解》 在游戏开发领域，Phaser是一个非常流行的开源JavaScript框架，专门用于创建2D HTML5游戏。本篇文章将深入探讨如何利用Phaser进行游戏开发，以“ConnectNumber”为例，...
打印机Phaser3200驱动
03-25
《Xerox富士施乐Phaser 3200MFP激光打印机Vista-64位驱动详解》 Xerox富士施乐Phaser 3200MFP是一款高效能的激光打印机，专为满足中小型企业及个人用户对高质量打印的需求而设计。这款打印机以其出色的打印速度、...
Java并发——Phaser详解
吴声子夜歌的博客
06-22 1124
Phaser Phaser中文翻译为相位器。它与CountDownLatch非常相似，允许我们协调线程的执行。与CountDownLatch相比，它具有一些额外的功能。 Phaser是在线程动态数需要继续执行之前等待的屏障。在CountDownLatch中，该数字无法动态配置，需要在创建实例时提供。 arriveAndAwaitAdvanve()方法： 方arriveAndAwaitAdvanceo的作用与 CountDownLatch类中的awai()方法大体一样,通过从方法的名称解释来看, arriv
Phaser-教程：Phaser 2（CE）教程游戏-用于2D游戏开发JavaScript框架
02-04
移相器教程 该存储库包含几个迷你游戏，这些游戏帮助我有效地学习了Phaser。 我已将每个游戏的代码分为称为课程的各个子文件夹（基本上是检查点） ） 安装 下载XAMPP.Clone或下载存储库并将其放置在htdocs中（位于XAMPP文件夹中） 现在，双击XAMPP并启动apache服务器打开任何浏览器，然后在文件路径后键入localhost example : http://localhost/BIKE/lesson3/ 注意 Tutorials are based on phaser version 2.
并发工具类（五） Phaser类
jinggod的博客
12-04 521
前言  JDK中为了处理线程之间的同步问题，除了提供锁机制之外，还提供了几个非常有用的并发工具类：CountDownLatch、CyclicBarrier、Semphore、Exchanger、Phaser；   CountDownLatch、CyclicBarrier、Semphore、Phaser 这四个工具类提供一种并发流程的控制手段；而Exchanger工具类则提供了在线程之间交换数据的
Phaser 使用介绍
weixin_43785662的博客
12-28 1764
本文将介绍 java.util.concurrent.Phaser，一个常常被大家忽略的并发工具。它和 CyclicBarrier 以及 CountDownLatch 很像，但是使用上更加的灵活，本文会进行一些对比介绍。 和之前的文章不同，本文不写源码分析了，就只是从各个角度介绍下它是怎么用的。本文比较简单，我觉得对于初学者大概需要 20 分钟左右吧。 其实我对这个需要多少时间很没概念，有没有读者愿意记录下所花费的时间，在评论区反馈一下。 使用示例 我们来实现一个小需求，启动 10 个线程执行任务，由于
java多线程之Phaser
eli850934234的专栏
11-19 313
简介 java多线程技术提供了Phaser工具类，Phaser表示“阶段器”，用来解决控制多个线程分阶段共同完成任务的情景问题。其作用相比CountDownLatch和CyclicBarrier更加灵活，例如有这样的一个题目：5个学生一起参加考试，一共有三道题，要求所有学生到齐才能开始考试，全部同学都做完第一题，学生才能继续做第二题，全部学生做完了第二题，才能做第三题，所有学生都做完的第三题
Phaser类详解
weixin_34268843的博客
04-25 191
　　Phaser允许并发多阶段任务。Phaser类机制是在每一步结束的位置对线程进行同步，当所有的线程都完成了这一步，才允许执行下一步。 　　一个Phaser对象有两种状态： 活跃态（Active）：当存在参与同步的线程的时候，Phaser就是活跃的，并且在每个阶段结束的时候进行同步。 终止态（Termination）：当所有参与同步的线程都取消注册的时候，Phaser就处于终止态，在终...
Java线程之Phaser
热门推荐
华丽的痘痘
04-23 1万+
Phaser是一个灵活的线程同步工具，他包含了CyclicBarrier和CountDownLatch的相关功能        首先，来看一下如何用Phaser替代CountDownLatch。对于CountDownLatch而言，有2个重要的方法，一个是await()方法，可以使线程进入等待状态，在Phaser中，与之对应的方法是awaitAdvance(int n)。CountDownL
phaser
weixin_34185364的博客
05-19 210
“phaser”是一个同步原语，它允许线程知道所有其他线程已经通过执行中的某个点，但没有阻塞任何这些线程。 在调用者想要在解除分配之前保证共享资源不再可见的情况下，它非常有用。 任何数量的线程都可以进入和退出由移相器保护的“关键区域”; 他们使用例程退出phaser_enter和phaser_exit。 这些功能是非等待，非阻塞，完全可重入，绝对可靠和异步信号安全。 另一个线程（一次最多一个）可以...
十一、移相器 Phaser
jysf98746的博客
10-18 215
适合用于具有多阶段处理的任务，在每个阶段有多个线程并行处理的场景。这样描述很抽象，我们举一个生活中的例子：有一个开发小组总共 4 个人，约定一起去旅游。这个工具类相对而言比较复杂，大家不要着急，结合后面的案例仔细体会。上述代码在注册好需要同步控制的所有线程之后，开启了每一个线程（每位同事）的处理。是不是又强大又抽象，没关系，我们通过一张图可以直白了解其提供的逻辑模型。工具类表达的概念和最基本用法，接着通过一个生活中的例子为大家解释。工具类的使用场合，然后通过简单的编码实现此场景，最后带领大家熟悉。
Java并发API详解与实战
"《精通 并发编程 JAVA》由哈维尔•费尔南德斯•冈萨雷斯著，唐富年译，详细讲解了Java并发API的重要元素，包括执行器框架、Phaser类、Fork/Join框架、流API、并发数据结构和同步机制，旨在帮助开发者构建高效并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值