java线程池详解

最新推荐文章于 2024-04-16 14:00:01 发布
最新推荐文章于 2024-04-16 14:00:01 发布
阅读量236 收藏 1
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37385585/article/details/113385851
版权

tips:右侧有导航

什么是线程池

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

线程池有什么优点

  1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗

  2. 提高响应速度，当任务到达时，任务可以不需要等待线程创建就能立即执行。

  3. 提高线程的课管理型。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，是用线程池可以进行统一的分配，调优，和监控

线程池有什么特点

线程复用，控制并发数；管理线程

线程池如何创建

Executor框架

java中的线程池 是通过 Executor 框架实现的，该框架中用到了以下几个类

Executors 是 Executor的工具类，类似于 Arrays是Array的工具类在这里插入图片描述

线程池玩的就是 ThreadPoolExecutor

Executors怎样创建线程池

使用Executors创建线程池常见的有3中方式

Executors.newFixedThreadPool ( int ) ------- 创建固定数量线程的线程池
/**
 * 使用 Executors.newFixedThreadPool(5); 方法创建一个线程
 *
 * 将线程池比喻成一个银行, 银行中共有5个开放的窗口办理业务, 现在有10个人来办理业务
 */
public class ExecutorsFixThread {
    public static void main(String[] args) {
        //创建5个固定数量线程的
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(() ->{
                System.out.println(Thread.currentThread().getName() + "\t开始办理");
            });
        }

        //关闭线程池
        fixedThreadPool.shutdown();
    }
}

执行结果如下
在这里插入图片描述

  1. 从代码执行结果可以知道 线程池中 线程可以复用

  2. 如果不关闭线程池，线程池会保持连接 不会关闭

使用 Executors.newFixedThreadPool 底层代码
在这里插入图片描述

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

Executors.newFixedThreadPool 创建的 corePoolSize 和 maximumPoolSize是一样的，使用的是 LinkedBlockingQueue

Executors.newSingleThreadExecutor ( ) ------- 创建单个线程的线程池
public class ExecutorsFixThread {
    public static void main(String[] args) {
        //创建5个固定数量线程的
        ExecutorService fixedThreadPool = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(() ->{
                System.out.println(Thread.currentThread().getName() + "\t开始办理");
            });
        }

        //关闭线程池
        fixedThreadPool.shutdown();
    }
}

执行结果如下
在这里插入图片描述

Executors.newSingleThreadExecutor 源码如下
在这里插入图片描述

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行

Executors.newSingleThreadExecutor 创建的 corePoolSize 和 maximumPoolSize都是1，使用的是 LinkedBlockingQueue

Executors.newCachedThreadPool ( ) ---- 创建一个带缓冲的线程
public class ExecutorsFixThread {
    public static void main(String[] args) {
        //创建5个固定数量线程的
        ExecutorService fixedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            //try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
            fixedThreadPool.execute(() ->{
                System.out.println(Thread.currentThread().getName() + "\t开始办理");
            });
        }

        //关闭线程池
        fixedThreadPool.shutdown();
    }
}

如果注释停顿的代码块
在这里插入图片描述

如果不注释停顿的代码块
在这里插入图片描述

此例可以说明 如果线程够用，就会只使用线程池中的一个线程，如果线程不够用，线程池就会多创建几个线程来用

源码如下：
8574

创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵回收空闲线程，若无可回收，则新建线程

Executors.newCachedThreadPool 将核心线程数设置成0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说 来了任务就创建线程运行，当线程空闲60s后，就销毁线程

工作中使用什么方式创建线程池

不使用Executors工具类创建线程池 阿里巴巴开发手册中说 不允许使用 Executors去创建，而是通过new ThreadPoolExecutor (... ) 的方式创建多线程

原因：

  1. 使用FixedThreadPool 和 SingleThreadPool：

允许请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM

  1. 使用 CachedThreadPool 和 ScheduledThreadPool：

语序的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM

线程池中的7大参数：

  1. corePoolSize：线程池中的常驻核心线程数 比如：银行中 周一到周5每天至少有5个窗口办理业务，常驻核心线程数就是5

  2. maximumPoolSize：线程池中能够容纳同时执行的最大线程数，此值必须大于等于1，maximumPoolSize = corePoolSize + 其他

  3. keepAliveTime：多余的空闲线程的存活时间 当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止

  4. unit：keepAliveTime的单位

  5. workQueue：任务队列，被提交单上位被执行的任务

  6. threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可

  7. handler：拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数 ( maximumPoolSize ) 时如何来拒绝请求执行的 runnable的策略

解释5：银行共有3个窗口，但是现在来了4个人办理业务，前3个人已经占用的银行的窗口，第4个人就只能待在候客区等待，等待的这个线程 就会被装在 workQueue(阻塞队列) 中

解释6：线程池中存在已经new好的线程，这些线程是怎样来的呢，就是通过 threadFactory 线程工厂 来创建的，一般使用默认的 threadFactory，但是如果想要修改的话 也是可以的，在说白一点 格力空调出厂的时候是白色的，自己可以把这个空调刷成红色，但是没有这个必要，正常情况下使用默认的。

解释7：什么叫做拒绝策略，拒绝策略有几种类型，应该如何使用
是什么

等待队列已经排满了，在也塞不下新任务的同时，maximumPoolSize也达到了最大值，无法继续为新任务服务

此时就应该由拒绝策略机制处理了

共有几种类型

拒绝策略共有4中情况，这4中拒绝策略全部都实现了 RejectedExecutionHandler接口

AbortPolicy ( 默认 ) ：直接抛出 RejectedExecutionException异常，阻止系统正常运行
public class ThreadPoolAbortPolicyDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //类似于一池N个工作线程，银行开通了N个受理窗口
        ExecutorService executorService = new ThreadPoolExecutor(
                1
                , 5
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(3)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy()
        );
        try {
          	// 是否抛出异常由 最大线程数和 阻塞队列联合决定， 当此时线程最大可以承受的压力是 5 + 3 = 8 超过8时会报错
            for (int j = 1; j <= 8; j++) {
                executorService.execute(() ->{
                    // 让线程sleep 5s 的目的是防止当前线程已经执行完成, 返回线程池后又被复用
                    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(Thread.currentThread().getName() + ", 开始执行");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭线程池
            executorService.shutdown();
        }
    }
}

当 j 的值为 8 时，程序正常执行
在这里插入图片描述

当 j 的值为 9 时出现异常
在这里插入图片描述

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

举个生活例子：开发人员和测试人员一起测试开发提测的功能，开发人员提测了以后就没管了给测试人员测试，测试测到一半的时候发现有bug，但是自己不能写代码不能修改这个bug，只能将通知提测的开发人员，修改这个bug ( 谁调用的，就将这个bug回退给谁，这个bug是一定要处理的 )

代码示例：

public class ThreadPoolCallerRunsPolicyDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //类似于一池N个工作线程，银行开通了N个受理窗口
        ExecutorService executorService = new ThreadPoolExecutor(
                1
                , 5
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(3)
                , Executors.defaultThreadFactory()
          // CallRunsPolicy
                , new ThreadPoolExecutor.CallerRunsPolicy()
        );
        try {
            for (int j = 1; j <= 15; j++) {
                executorService.execute(() ->{
                    // 让线程sleep 5s 的目的是防止当前线程已经执行完成, 返回线程池后又被复用
                    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(Thread.currentThread().getName() + ", 开始执行");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭线程池
            executorService.shutdown();
        }
    }
}

从代码可以看到，虽然线程池可以承受的最压力是8，但是我设置的是15， 程序没有抛出异常，而是 将线程池处理不过来的任务 交给了main线程去执行了，

在生活实例中， main线程相当于是开发人员，线程池相当于是测试人员，现在测试人员处理不过来了，那么只能将他们处理不过来的任务交给开发人员处理 (由main线程执行 )
在这里插入图片描述

main线程执行的任务 + 线程池执行的任务 = 15

DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
public class ThreadPoolDiscardOldestPolicyDemo {
    public static void main(String[] args) {
        //类似于一池N个工作线程，银行开通了N个受理窗口
        ExecutorService executorService = new ThreadPoolExecutor(
                1
                , 5
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(3)
                , Executors.defaultThreadFactory()
                // CallRunsPolicy
                , new ThreadPoolExecutor.DiscardOldestPolicy()
        );
        try {
            for (int j = 1; j <= 15; j++) {
                int finalJ = j;
                executorService.execute(() ->{
                    // 让线程sleep 5s 的目的是防止当前线程已经执行完成, 返回线程池后又被复用
                    try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(finalJ + ", "+Thread.currentThread().getName() + ", 开始执行");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭线程池
            executorService.shutdown();
        }
    }
}

执行结果如下，虽然最后一个值是 15，但是总共执行的任务并没有15个，实际执行的只有8个
在这里插入图片描述

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

    public static void main(String[] args) {
        //类似于一池N个工作线程，银行开通了N个受理窗口
        ExecutorService executorService = new ThreadPoolExecutor(
                1
                , 5
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(3)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.DiscardPolicy()
        );
        try {
            for (int j = 1; j <= 15; j++) {
                int finalJ = j;
                executorService.execute(() ->{
                    // 让线程sleep 5s 的目的是防止当前线程已经执行完成, 返回线程池后又被复用
                    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(finalJ + ", "+Thread.currentThread().getName() + ", 开始执行");
                });
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭线程池
            executorService.shutdown();
        }
    }
}

执行结果如下
在这里插入图片描述

DiscardPolicy 和 DiscardOldestPolicy的区别就是：DiscardPolicy不管怎样执行，都是丢弃掉 线程池最大压力 ( 8个 ) 之后的那几个任务， 而DiscardOldestPolicy是丢弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务

线程池原理

例子 – 和生活中的实例 ( 银行办理业务 ) 结合在一起：
在这里插入图片描述

核心线程数：目前银行开放的窗口，最大核心数 包含核心线程数 + 其他

最大线程数：银行所有可以开放的窗口

阻塞队列： 等候办理业务的候客区

  1. 在创建了线程池后，开始等待请求 ------ 新开了一家银行后 开始办理业务

  2. 当调用execute() 方法添加一个请求任务时，线程池会做出如下判断 ------ 当有一个人来办理业务的时候开始执行

    1. 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务： ------ 如果当日开放的窗口没有人，那么直接就去办理业务

    2. 如果正在运行的线程数量大于或等于 corePoolSize，将这个任务放入到阻塞队列中 ------ 如果当日开放的所有窗口有人，就去候客区等着(候客区的位子也是有限的)

    3. 如果队列满了，且正在运行的线程数量小于 maximumPoolSize，那么要创建非核心线程立刻运行这个任务

      1. ------ 如果当日开放的窗口满了，阻塞队列也满了，但是银行还有多余的可以开放的窗口，那么此时 开放多余的窗口，但是 新来的线程(不在任务队列，也不在等候区，而是从大门外进来的新用户) 直接去刚刚开放的窗口办理业务

    4. 如果队列满了，且正在运行的线程数量大于等于 maximumPoolSize，那么线程池会启动饱和策略来执行。 ------ 如果最大核心线程数满了，等候区也满了，此时就会启动拒绝策略了

  3. 当一个线程任务完成时，他会从队列中取下一个任务来执行 ------ 当前一个人已经办完业务了，那么窗口就会让等候区的人来办理业务

  4. 当一个线程无事可做 超过一定的时间 ( keepAliveTime ) 时，线程会判断

    1. 如果当前运行的线程数大于corePoolSize，那么这个线程就会被停掉，所有线程池的所有任务完成后，他最终会收缩到corePoolSize的大小
    2. ----- 当银行当日客流高峰已经过去了，且今日核心工作人员以外的来加班的人已经无事可做了，那么领导为了节省开销，就会让这些来加班的人回家
验证2.3
public class TestNewThreadWhenBlockingQueueFull {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        for (int i = 1; i <= 8; i++) {
            int finalI = i;
            threadPoolExecutor.execute(() -> {
              	// 目的是让当前线程等待，不然CPU执行速度太快了，可能发现不了效果
                try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread().getName()+"号窗口开始服务,"+ finalI +"号顾客");
            });
        }
	      // 关闭线程池
      	threadPoolExecutor.shutdown();
    }
}

运行结果：
在这里插入图片描述

运行结果中 按道理来说，

1号窗口 1号顾客，

2号窗口 2号顾客，

3号窗口如果不是直接执行新来的人的话 就是阻塞队列中的3号顾客，但是 现在是执行新来的人，所以就变成了6号顾客，7,8号顾客同理

最后开始执行 3，4，5号顾客

示意图如下：
在这里插入图片描述

怎样手写一个线程池

按照线程池原理图中的例子来写

ExecutorService executorService = new ThreadPoolExecutor(
                	2
                , 5
                , 10
                , TimeUnit.SECONDS
                , new LinkedBlockingQueue<>(4)
  				//线程工厂都使用默认的 (照着源码抄就完事了)
                , Executors.defaultThreadFactory()
                , new ThreadPoolExecutor.AbortPolicy()
        );

注意：

//LinkedBlockingQueue 一定要附上初始值，如果使用空参数的构造方法阻塞队列中的初始值是 Integer.MAX_VALUE
在这里插入图片描述

赋上初始值 使用的不是一个构造方法
在这里插入图片描述

线程池中的最大线程数 应该如何配置

什么叫做单核CPU，多核CPU

举个例子：

单核CPU就是 一个小丑丢多个球

多核CPU就是 多个小丑 没人丢1个球

怎样通过代码获取cpu的核心线程数
int i = Runtime.getRuntime().availableProcessors();
根据业务类型来区分，业务分为CPU密集型和IO密集型
CPU密集型
什么是CPU密集型

该任务需要大量的运算，而没有阻塞，CPU一直全速运行，

CPU密集型任务只有在真正的多核CPU上才可以得到加速 ( 通过多线程 ) ，在单核CPU上，无论开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些

如何配置

CPU密集型任务配置尽可能少的线程数量

公式：CPU核数 + 1个线程的线程池

IO密集型
是什么：

该任务需要大量的IO，既大量的阻塞

在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待，所以IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间

IO密集型时 大部分线程都阻塞，所以需要多配置线程数

方式1：IO密集型任务线程并不是一直在执行任务，应该配置尽可能多的线程 公式： CPU核数 * 2

方式2：CPU核心数 /(1-阻塞系数) ， 阻塞系数一般在0.8~0.9之间

举个例子： 8核CPU： 8/(1 - 0.9) = 80 个线程数

All-Might
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 线程池详解
09-02
本文给大家总结了java中的线程池的相关问题，非常的详细也很实用，有需要的小伙伴可以参考下。
java线程池详解文档
03-09
相对系统的了解java 线程池的知识点
JAVA线程池详解（ThreadPoolExecutor）
ChengHuanHuaning的博客
09-30 7601
随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。如果你要成为一个好的工程师，还是得比较好地掌握这个知识，很多线上问题都是因为没有用好线程池导致的。即使你为了谋生，也要知道，这基本上是面试必问的题目，而且面试官很容易从被面试者的回答中捕捉到被面试者的技术水平。
线程池的七个核心参数
lhd992692552的博客
01-13 3万+
先看下源码 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable&gt
IO密集型任务和CPU密集型任务
最新发布
卓越之识论道，平常之识论事，狭隘之识论人
04-16 1377
IO密集型任务和CPU密集型任务区分，分别讲述适合使用多线程的场景
线程池工作原理
热门推荐
promiseful的博客
11-08 4万+
一、线程池默认工作流程 1、线程在有任务的时候会常见核心的线程数corePoolSize 2、当线程满了（有任务但是线程被使用完）不会立即扩容,而是放到阻塞队列中,当阻塞队列满了之后才会继续创建线程。 3、如果队列满了,线程数达到最大线程数则会执行拒绝策略。 4、当线程数大于核心线程数事,超过KeepAliveTime(闲置时间),线程会被回收,最终会保持corePoolSize个线程。 二、五种实现 1、newSingleThreadExecutor() 池里只有一条线程,如果线程因为异常而停止，会自动
Java线程池总结
时光时光慢一点的博客
08-07 579
为什么要用线程池 1.线程池可以节约创建线程和销毁线程的时间。 2.线程池可以对线程进行管理。 3.线程池把执行机制和工作单元分离。工作单元就是Runnable和Callable，执行单元就是由Executor框架提供。 Java中的线程池 线程池的核心接口与类 核心接口是Executor和ExecutorService。ExecutorService就是线程池的接口定义。 ...
线程池详解
qq_52463861的博客
11-06 4973
线程池
Java 线程池详解，图文并茂.pdf
11-17
Java 线程池详解 Java 线程池是一种高效的线程管理机制，它可以避免频繁创建和销毁线程，从而提高系统性能。线程池的设计思想源于生活，例如工厂的生产流程可以看作是一个线程池。 在 Java 中，线程池的实现类是 ...
Java 线程池详解及实例代码
09-01
主要介绍了Java 线程池的相关资料,并符实例代码，帮助大家学习参考，需要的朋友可以参考下
Java 线程池详解及创建简单实例
08-31
Java线程池是一种高效管理并发任务的机制，它通过复用已存在的线程来减少线程创建和销毁的开销，从而提高系统的整体性能。本文将深入解析Java线程池的工作原理，并给出创建简单实例的步骤。 线程池的核心在于`java....
Java线程池技术详解
06-14
在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁。如何利用已有对象来...
JAVA线程池原理实例详解
08-26
JAVA线程池原理实例详解 JAVA线程池是java中的一种高效的线程管理机制，它可以控制线程的创建、销毁和复用，从而提高系统的性能和可靠性。下面我们将详细介绍JAVA线程池的原理、创建、使用方法及相关注意事项。 一...
深入java线程池的使用详解
12-26
在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提于交和执行是同时进行的，如果你想对任务的执行进行调度或是控制 同时执行的线程数量就需要额外编写代码来完成。5.0里提供了一个新的...
Java线程池的拒绝策略实现详解
08-25
Java线程池的拒绝策略实现详解 Java线程池的拒绝策略是指当线程池中的线程数量达到最大值时，如何处理新的任务提交的策略。这个策略是由RejectedExecutionHandler接口定义的，提供了四种默认的拒绝策略：...
线程池的核心参数以及运行原理
xiaohuihuiaz的博客
04-09 3022
java创建多线程有如下四种方式： 继承Thread类创建线程 实现Runnable接口创建线程（无返回值） 使用Callable和Future创建线程(有返回值) 使用线程池创建（使用java.util.concurrent.Executor接口） Note：Thread其实也是Runable的一种,Thread类也是实现了Runable接口. ...
「Java 并发编程」详解线程池实现原理及常见问题(核心线程=正式工，非核心线程=合同工)
Hanko的专栏
04-20 2590
核心线程数（正式工） 等待队列（合同工） 最大线程数（所有人员）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值