11、ThreadPool线程池

最新推荐文章于 2023-03-15 20:21:03 发布
最新推荐文章于 2023-03-15 20:21:03 发布
阅读量220 收藏
点赞数
分类专栏： JUC上 文章标签： java jvm 开发语言
了凡啊
本文链接：https://blog.csdn.net/qq_38749525/article/details/126790221
版权

11.1、多线程的概念

线程池（英语:thread pool ) ：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。

线程池的优势：线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

11.2、主要特点

  • 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
  • 提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。
  • 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。·
  • Java 中的线程池是通过Executor框架实现的，该框架中用到了Executor，Executors ，Execu torService ，ThreadPoolExecutor这几个类。

11.3、线程池类的架构关系

11.4、线程池分类

  • Executors.newFixedThreadPool(int)：一池N线程
  • Executors.newSingleThreadExecutor()：一个任务一个任务的执行，一池一线程
  • Executors.newCacheThreadPool()：线程池根据需求创建线程，可扩容。

案例演示

package com.ae.juc.threadPool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //一池5线程 【模拟银行5个窗口】
        ExecutorService threadPool1 = Executors.newFixedThreadPool(5);

        //一池1线程 【模拟银行1个窗口】
        ExecutorService threadPool2 = Executors.newSingleThreadExecutor();

        //一池可扩容线程
        ExecutorService threadPool3 = Executors.newCachedThreadPool();

        //20个客户办业务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool3.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool1.shutdown();
        }
    }
}

11.5、线程池底层原理

查看三个创建线程的底层代码，发现他们创建线程的方式都是一样的，都是调用new ThreadPoolExecutor(),传入不同的参数来实现的。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}


public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}


public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

11.6、线程池七个参数

/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters.
*
* @param corePoolSize the number of threads to keep in the pool, even
*        if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
*        pool
* @param keepAliveTime when the number of threads is greater than
*        the core, this is the maximum time that excess idle threads
*        will wait for new tasks before terminating.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
*        executed.  This queue will hold only the {@code Runnable}
*        tasks submitted by the {@code execute} method.
* @param threadFactory the factory to use when the executor
*        creates a new thread
* @param handler the handler to use when execution is blocked
*        because the thread bounds and queue capacities are reached
* @throws IllegalArgumentException if one of the following holds:<br>
*         {@code corePoolSize < 0}<br>
*         {@code keepAliveTime < 0}<br>
*         {@code maximumPoolSize <= 0}<br>
*         {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue}
*         or {@code threadFactory} or {@code handler} is null
*/
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
        null :
    AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
    }
corePoolSize：常驻线程数量【例如银行有5个窗口】
maximumPoolSize：最大线程数量【银行最大可以开10个窗口】
keepAliveTime：线程存活时间【例如银行多出来的窗口多久关闭】
unit：时间的单位
workQueue：阻塞队列，常驻线程数据都被占用完了，那么这些任务就会放到阻塞队列中排队等待
threadFactory：线程工厂，用于创建线程的
handler：拒绝策略【银行办理业务，常驻5个窗口和最大10个窗口都已经满了，这时候银行就不在接收新顾客，叫他们去其它银行办理，这就是拒绝策略】

11.7、线程池底层工作流程和拒绝策略

11.7.1、工作原理

  1. 在创建了线程池后，开始等待请求
  2. 当调用 execute() 方法添加一个请求任务时，线程池会做出如下判断：
  • 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务
  • 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务 放入队列
  • 如果这个时候队列满了且正在运行的线程数量还小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务
  • 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会 启动饱和拒绝策略来执行
  1. 当一个线程完成任务时，它会从队列中取下一个任务来执行
  2. 当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
  • 如果当前运行的线程数大于 corePoolSize，那么这个线程就会被停掉
  • 所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小

11.7.2、如何设置合理参数

根据自己的要求合理配置即可

// 自定义线程池
ExecutorService threadPool = new ThreadPoolExecutor(
				                2, // 线程池中的常驻核心线程数
				                5, // 最大线程数
				                2L,// 活跃时间
				                TimeUnit.SECONDS,
				                new LinkedBlockingQueue<>(3), // 任务队列数
				                Executors.defaultThreadFactory(),
				                // AbortPolicy 拒绝策略
				                new ThreadPoolExecutor.AbortPolicy());

11.7.3、线程池的拒绝策略

什么是拒绝策略？

等待队列已经排满了，再也塞不下新任务了。同时，线程池中的 max 线程也达到了，无法继续为新任务服务。这个时候我们就需要拒绝策略机制合理地处理这个问题

有哪些拒绝策略？

AbortPolicy()

直接抛出 RejectExecutionException 异常阻止系统正常运行

package com.ae.juc.threadPool;

import java.util.concurrent.*;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//拒绝策略

        //处理20个任务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

运行结果

pool-1-thread-1 办理业务
pool-1-thread-2 办理业务
pool-1-thread-2 办理业务
pool-1-thread-2 办理业务
pool-1-thread-2 办理业务
pool-1-thread-3 办理业务
pool-1-thread-4 办理业务
pool-1-thread-5 办理业务
java.util.concurrent.RejectedExecutionException: Task com.ae.juc.threadPool.ThreadPoolDemo2$$Lambda$1/1023892928@4dd8dc3 rejected from java.util.concurrent.ThreadPoolExecutor@6d03e736[Running, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 2]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at com.ae.juc.threadPool.ThreadPoolDemo2.main(ThreadPoolDemo2.java:20)

CallerRunsPolicy()

“调用者运行” 一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

package com.ae.juc.threadPool;

import java.util.concurrent.*;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());//拒绝策略

        //处理20个任务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

运行结果

pool-1-thread-1 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-2 办理业务
main 办理业务
pool-1-thread-5 办理业务
pool-1-thread-5 办理业务
pool-1-thread-1 办理业务
pool-1-thread-3 办理业务
pool-1-thread-4 办理业务
main 办理业务
main 办理业务
pool-1-thread-2 办理业务
pool-1-thread-1 办理业务
pool-1-thread-5 办理业务
main 办理业务
pool-1-thread-2 办理业务
pool-1-thread-1 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务

DiscardOldestPolicy()

抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

package com.ae.juc.threadPool;

import java.util.concurrent.*;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策略

        //处理20个任务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

运行结果

pool-1-thread-1 办理业务
pool-1-thread-5 办理业务
pool-1-thread-4 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-4 办理业务
pool-1-thread-5 办理业务
pool-1-thread-1 办理业务

DiscardPolicy()

该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种策略

package com.ae.juc.threadPool;

import java.util.concurrent.*;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());//拒绝策略

        //处理20个任务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

运行结果

pool-1-thread-1 办理业务
pool-1-thread-4 办理业务
pool-1-thread-4 办理业务
pool-1-thread-4 办理业务
pool-1-thread-3 办理业务
pool-1-thread-2 办理业务
pool-1-thread-4 办理业务
pool-1-thread-5 办理业务

11.8、自定义线程池

package com.ae.juc.threadPool;

import java.util.concurrent.*;

public class ThreadPoolDemo2 {
    public static void main(String[] args) {
        //创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());//拒绝策略

        //处理20个任务
        try {
            for (int i = 1; i <= 20; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " 办理业务");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}
了凡啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
threadpool11:快速，无锁，跨平台的C ++ 11线程池库，旨在实现轻量级且简单
05-02
线程池11 一个快速的，几乎没有锁的，跨平台的，全CPU的处理器，它利用C ++ 11功能实现了线程池。 您可以在标题注释中找到已失效的简单API文档。 这个项目最初是在几个小时的空闲时间中开发的，因为我找不到适合我需要的简单轻量级线程池库。 。 与OpenMP相比，threadpool11的性能 这是在树中找到OpenMP演示的结果。 您机器的硬件并发度是8 threadpool11执行花费了22704毫秒。 threadpool11（没有将来）的执行花费了21198毫秒。 openmp执行花费了21663毫秒。 openmp执行（动态计划）花费了21335毫秒。 gcc -v gcc版本8.2.1 20181127（GCC） 测试代码可以在项目树中找到。 通过，我很高兴听到您对项目的建议/想法。 所有非' -dev '分支都可以安全使用，但是更喜欢最新版本。 建
C++11 ThreadPool总结
技术笔记
12-22 2373
github两个实现 https://github.com/progschj/ThreadPool https://github.com/mtrebi/thread-pool 最先找到第一个的，看了一头雾水，过于难懂，第二个和第一个实现有些地方一样，但是文档写的很全。 其中enqueue的实现在看了example的代码之后，因为不熟悉拉姆达表达式，造成了很大的困扰。 ThreadPool pool(4); std::vector< std::future<.
阻塞线程池
06-11 2795
相关文档内容： 排队 所有 BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互：     如果运行的线程少于 corePoolSize，则 Executor 始终首选添加新的线程，而不进行排队。    如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列，而不添加新的线程。    如果无法将请求加入
基于C++11的线程池(threadpool),简洁且可以带任意多的参数
木牛的博客
03-15 1361
原文地址 :咳咳。C++11 加入了线程库，从此告别了标准库不支持并发的历史。然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等。线程池(thread pool)这个东西，在面试上多次被问到，一般的回答都是：“管理一个任务队列，一个线程队列，然后每次取一个任务分配给一个线程去做，循环往复。” 貌似没有问题吧。但是写起程序来的时候就出问题了。废话不多说，先上实现，然后再啰嗦。
11.线程系列- 线程池
qq_32062699的博客
12-16 217
什么是线程池 大家用jdbc操作过数据库应该知道，操作数据库需要和数据库建立连接，拿到连接之后才能操作数据库，用完之后销毁。数据库连接的创建和销毁其实是比较耗时的，真正和业务相关的操作耗时是比较短的。每个数据库操作之前都需要创建连接，为了提升系统性能，后来出现了数据库连接池，系统启动的时候，先创建很多连接放在池子里面，使用的时候，直接从连接池中获取一个，使用完毕之后返回到池子里面，继续给其他需要者使用，这其中就省去创建连接的时间，从而提升了系统整体的性能。 线程池和数据库连接池的原理也差不多，创建线程去
基于C++11的threadpool线程池(简洁且可以带任意多的参数)
08-26
C++11 加入了线程库，从此告别了标准库不支持并发的历史。然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等
C++11 线程池 ThreadPool
12-21
C++11 线程池 ThreadPool 单例 线程池，实现全局唯一。
C#多线程ThreadPool线程池详解
08-30
主要介绍了C#多线程ThreadPool线程池的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
threadpool线程池
07-31
自己实现的Python实现的线程池源码，测试通过
第三节：ThreadPool的线程开启、线程等待、线程池的设置、定时功能
weixin_33979363的博客
01-02 291
一. ThreadPool简介 　　ThreadPool简介：ThreadPool是一个线程池，当你需要开启n个线程时候，只需把这个指令抛给线程池，它将自动分配线程进行处理，它诞生于.Net 2.0时代。 　　ThreadPool与Thread的区别： 　　　　①：Thread每开启一个异步任务，就需要使用一个Thread，具有专一性，即使Thread已经死掉，仍然需要占用资源。 　　　　...
线程池的优雅关闭探究
yichen0429的博客
08-20 2356
线程池优雅停机方案 简介 在开发中使用线程池去执行异步任务是比较普遍的操作，然而虽然有些异步操作我们并不十分要求可靠性和实时性，但总归业务还是需要的。如果在每次的服务发版过程中，我们不去介入线程池的停机逻辑，那么很有可能就会造成线程池中队列的任务还未执行完成，自然就会造成数据的丢失。 探究 注意，本文所有前提是对进程进行下线时使用的是kill 我们知道Spring已经实现了自己的优雅停机方案，详细请参考org.springframework.context.support.AbstractApplicati
基于 C++11 的线程池 threadpool , 简洁且可以带任意多的参数
轻松学C语言
07-04 626
点击蓝字关注我们咳咳。C++11 加入了线程库，从此告别了标准库不支持并发的历史。然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等。线程池(thread pool)这个东西，在面试上多次被问到，一般的回答都是：“管理一个任务队列，一个线程队列，然后每次取一个任务分配给一个线程去做，循环往复。” 貌似没有问题吧。但是写起程...
c++11线程池实现
热门推荐
zdarks的专栏
07-22 4万+
咳咳。c++11 加入了线程库，从此告别了标准库不支持并发的历史。然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等。线程池(thread pool)这个东西，在面试上多次被问到，一般的回答都是：“管理一个任务队列，一个线程队列，然后每次取一个任务分配给一个线程去做，循环往复。” 貌似没有问题吧。但是写起程序来的时候就出问题了。
C++ 11线程池 ThreadPool
qq_42896106的博客
07-23 391
线程池 ThreadPool 半同步半异步线程池(简略版)C++11实现,详细解析 同步队列 SynchronousQueue.hpp #include <list> #include <mutex> #include <thread> #include <condition_variable> #include <iostream> using namespace std; template<typename T> class Sy
java线程池thread pool使用总结
zpzkitt的专栏
12-14 9153
一、线程池的用途 线程池主要是为了解决以下几个问题： 1、为多线程执行琐碎的任务提供支持 2、避免线程创建销毁过程的资源消耗 3、控制资源的使用，根据实际情况合理高效利用资源 4、 二、java提供的线程池结构 java jdk中提供了线程池的创建接口，已经可以很方便对线程的管理和使用了。 上图是线程池和调度线程的UML图 1、创建线程就是用ThreadPoolExecuto...
主线程的子线程信息pool-1-thread-1
zwq1457的专栏
11-03 1万+
11-02 05:19:00.989 912 931 I am_anr : [0,31740,com.android.vending,952811205,Broadcast of Intent { act=android.intent.action.PACKAGE_REMOVED dat=package:com.android.vending flg=0x4000010 cmp=com.
java 管道断开_jdbc 断开的管道
weixin_33806859的博客
03-05 473
18:34:50.032 [pool-11-thread-10] INFO o.a.http.impl.execchain.RetryExec - I/O exception (java.net.SocketException) caught when processing request to {}->http://35.26.59.191:8123: >断开的管道18:34:50...
【线程】ThreadPool 线程池 Executors 实战 （十九）
Sword52888的博客
10-05 302
Executors 四个常用方法
c# threadpool 线程池
最新发布
04-15
C#中的线程池（ThreadPool）是一种用于管理和复用线程的机制。它可以帮助我们更有效地使用系统资源，并提高多线程编程的性能和可伸缩性。 线程池的主要作用是在应用程序中维护一组可重用的线程，这些线程可以被分配给执行某些任务。当我们需要执行一个任务时，可以从线程池中获取一个空闲线程来执行任务，而不需要每次都创建和销毁线程，从而减少了线程创建和销毁的开销。 C#中的线程池提供了一些方法来管理线程池的行为，例如： 1. ThreadPool.QueueUserWorkItem：将一个工作项添加到线程池队列中，线程池会自动选择一个空闲线程来执行该工作项。 2. ThreadPool.SetMinThreads：设置线程池中的最小线程数。 3. ThreadPool.SetMaxThreads：设置线程池中的最大线程数。 4. ThreadPool.GetAvailableThreads：获取当前可用的线程数。 5. ThreadPool.GetMaxThreads：获取线程池中的最大线程数。 使用线程池可以带来以下好处： 1. 减少线程创建和销毁的开销，提高性能。 2. 控制并发线程数量，避免过多的线程导致系统资源耗尽。 3. 提供了一种简单的方式来管理多个任务的执行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

了凡啊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值