十一、 JDK线程池

最新推荐文章于 2024-06-16 14:21:07 发布
最新推荐文章于 2024-06-16 14:21:07 发布
阅读量847 收藏 2
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43374578/article/details/120694367
版权

一、JDK线程池

1. 类图

在这里插入图片描述

2. 线程状态

  • ThreadPoolExecutor 使用int的高3位来表示线程池状态，低29位表示线程数量

在这里插入图片描述

二、ThreadPoolExecutor

1. 构造方法

int corePoolSize:                     核心线程数
int maximumPoolSize：                 最大线程数
long keepAliveTime：                  救急线程数执行任务完后存活时间
TimeUnit unit：                       救急线程数执行任务完后存活时间
BlockingQueue<Runnable> workQueue：   阻塞队列
ThreadFactory threadFactory：         线程生产工厂，为线程起名字
RejectedExecutionHandler handler：    拒绝策略 

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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

2. 核心线程和救急线程

1. 核心线程： 执行完任务后，会继续保留在线程池中

2. 救急线程：如果阻塞队列已满，并且没有空余的核心线程。那么会创建救急线程来执行任务
  2.1 任务执行完毕后，这个线程就会被销毁(临时工)
  2.2 必须是有界队列，如果是无界队列，则不会创建救急线程

3. 有界队列，核心线程满负荷，队列已满，无空余救急线程，才会执行拒绝策略

3. JDK拒绝策略

  • 如果线程达到最大线程数，救急线程也满负荷，且有界队列也满了，JDK 提供了4种拒绝策略
AbortPolicy:           调用者抛出RejectedExecutionException,  默认策略
CallerRunsPolicy:      调用者运行任务
DiscardPolicy:         放弃本次任务
DiscardOldestPolicy:   放弃队列中最早的任务，本任务取而代之

在这里插入图片描述

三、Executors工厂方法

  • 默认的构造方法来创建线程池，参数过多，JDK提供了工厂方法，来创建线程池

1. 固定大小

  • 核心线程数 = 最大线程数，救急线程数为0
  • 阻塞队列：无界
# 应用场景
任务量已知，但是线程执行时间较长
执行任务后，线程并不会结束

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

package com.dreamer.multithread.day09;

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

public class Demo01 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        /** 执行任务
         * 
         * pool-1-thread-2running
         * pool-1-thread-1running
         * pool-1-thread-1running
         */
        pool.execute(() -> System.out.println(Thread.currentThread().getName() + "running"));
        pool.execute(() -> System.out.println(Thread.currentThread().getName() + "running"));
        pool.execute(() -> System.out.println(Thread.currentThread().getName() + "running"));
    }
}

2. 带缓冲线程池

  • 核心线程数为0, 最大线程数为Integer的无限大
  • 全部是救急线程，等待时间是60s，60s后就会消亡
  • SynchronousQueue: 容量为0，只能存放一个，进来一个，必须出去后，后续的才能进来
  • 整个线程池数会随着任务数目增长，1分钟后没有其他活动会消亡
# 应用场景
1. 时间较短的线程
2. 数量大，任务执行时间长，会造成  OutOfMmeory问题

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

3. 单线程池

  • 线程池大小始终为1个，不能改变线程数
  • 相比自定义一个线程来执行，线程池可以保证前面任务的失败，不会影响到后续任务
# 1. 和自定义线程的区别
自定义线程：  执行多个任务时，一个出错，后续都能不能执行了
单线程池：    一个任务失败后，会结束出错线程。重新new一个线程来执行下面的任务

# 2. 执行顺序
单线程池： 可以保证所有任务都是串行

# 3. 和newFixedThreadPool的区别
newFixedThreadPool:  可以修改线程大小
newSingleThreadExecutor:   不可以修改

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

package com.dreamer.multithread.day09;

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

public class Demo03 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        /*第一个任务执行失败后，后续任务会继续执行*/
        pool.execute(() -> {
            int i = 1 / 0;
            System.out.println(Thread.currentThread().getName() + " first running");
        });

        pool.execute(() -> {
            System.out.println(Thread.currentThread().getName() + " second running");
        });

        pool.execute(() -> {
            System.out.println(Thread.currentThread().getName() + " third running");
        });
    }
}

四、提交任务

  • ExecutorService接口

1. execute

void execute(Runnable command);

2. submit

Future<?> submit(Runnable task);

// 可以从 Future 对象中获取一些执行任务的最终结果
<T> Future<T> submit(Runnable task, T result);

<T> Future<T> submit(Callable<T> task);

package com.dreamer.multithread.day09;

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

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newCachedThreadPool();
        // future的一些执行结果
        Future<?> result = pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " running");
            }
        });

        TimeUnit.SECONDS.sleep(2);

        System.out.println("is task done: " + result.isDone());
        System.out.println("is task cancelled:" + result.isCancelled());
    }
}

package com.dreamer.multithread.day09;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newCachedThreadPool();

        // 返回具体的结果
        Future<String> result = pool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                System.out.println(Thread.currentThread().getName() + " running");
                return "success";
            }
        });
        TimeUnit.SECONDS.sleep(2);
        System.out.println("is task done: " + result.isDone());
        System.out.println("is task canceled: " + result.isCancelled());
        // 获取结果的时候，主线程会阻塞
        System.out.println("task result: " + result.get());
    }
}

3. invokeAll

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
    throws InterruptedException;

package com.dreamer.multithread.day09;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Demo2 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newCachedThreadPool();

        Collection<Callable<String>> tasks = new ArrayList();
        for (int i = 0; i < 10; i++) {
            int round = i;
            tasks.add(new Callable() {
                @Override
                public Object call() throws Exception {
                    System.out.println(Thread.currentThread().getName() + " running");
                    return "success:" + round;
                }
            });
        }

        List<Future<String>> results = pool.invokeAll(tasks);
        for (Future<String> result : results) {
            System.out.println(result.get());
        }
    }
}

4. invokeAny

  • 集合中之要有一个任务执行完毕，其他任务就不再执行
package com.dreamer.multithread.day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Test03 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService service = Executors.newFixedThreadPool(1);
        Collection<Callable<String>> tasks = new ArrayList<>();

        tasks.add(() -> {
            System.out.println("first task");
            TimeUnit.SECONDS.sleep(1);
            return "success";
        });

        tasks.add(() -> {
            System.out.println("second task");
            TimeUnit.SECONDS.sleep(2);
            return "success";
        });


        tasks.add(() -> {
            System.out.println("third task");
            TimeUnit.SECONDS.sleep(3);
            return "success";
        });
        // 任何一个任务执行完后，就会返回结果
        String result = service.invokeAny(tasks);
        System.out.println(result);
    }
}

五、关闭线程池

1. shutdown

  • 将线程池的状态改变为SHUTDOWN状态
  • 不会接受新任务，已经提交的任务不会停止
  • 不会阻塞调用线程的执行
void shutdown();

package com.dreamer.multithread.day09;

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

public class Demo04 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " first running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " second running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " third running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 不会阻塞主线程的执行
        pool.shutdown();
        System.out.println("main thread ending");

    }
}

2. shutdownNow

  • 不会接受新任务
  • 没执行的任务会打断
  • 将等待队列中的任务返回
List<Runnable> shutdownNow();

package com.dreamer.multithread.day09;

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

public class Demo04 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " first running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " second running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        pool.submit(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName() + " third running");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 不会阻塞主线程的执行
        List<Runnable> leftOver = pool.shutdownNow();
        System.out.println(leftOver.size()); // 2
        System.out.println("main thread ending"); 

    }
}

六、线程池数量

  • 过小，导致cpu资源不能充分利用，浪费性能
  • 过大，线程上下文切换，导致占用内存过多，浪费性能

1. CPU密集型

  • 如果线程的任务主要是和cpu资源打交道，成为CPU密集型
  • 线程数量： 核心数+1
  • +1: 保证某线程由于某些原因(操作系统方面)导致暂停时，额外线程可以启动，不浪费CPU资源

2. IO密集型

  • IO操作，RPC调用，数据库访问时，CPU是空闲的，称为IO密集型
  • 线程数 = 核数* 期望cpu利用率* (cpu计算时间+cpu等待时间)/cpu计算时间

在这里插入图片描述

七、调度功能

1. 延时执行

  • 如果希望线程延时执行任务
package com.dreamer.multithread.day09;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo05 {
    public static void main(String[] args) {
        // 两个线程，分别可以延时执行不同的任务
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);

        // 延时1s后执行
        pool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " first running");
            }
        }, 1, TimeUnit.SECONDS);

        // 延时5s后执行
        pool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " second running");
            }
        }, 5, TimeUnit.SECONDS);
    }
}

package com.dreamer.multithread.day09;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo06 {
    public static void main(String[] args) {
        // 如果是单个线程，则延时的任务是串行执行的
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);

        // 如果一个线程出错，则会再次创建一个线程来执行任务
        pool.schedule(new Runnable() {
            @Override
            public void run() {
                int i = 1 / 0;
                System.out.println(Thread.currentThread().getName() + " first running");
            }
        }, 1, TimeUnit.SECONDS);

        pool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " second running");
            }
        }, 2, TimeUnit.SECONDS);
    }
}

2. 定时执行

  • scheduleAtFixedRate
  • scheduleWithFixedDelay
package com.dreamer.multithread.day09;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Demo07 {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);

        // 定时执行任务
        pool.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("task is running");
            }
        }, 3, 2, TimeUnit.SECONDS);
        //  初始延时，   任务间隔时间，    任务间隔时间单位
    }
}

八、异常处理

1. 不处理异常

  • 任务执行过程中，业务中的异常并不会抛出
package com.dreamer.multithread.day09;

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

public class Demo08 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(new Runnable() {
            @Override
            public void run() {
                int i = 1 / 0;
                System.out.println(Thread.currentThread().getName() + " task running");
            }
        });
    }
}

2. 任务执行者自己处理

package com.dreamer.multithread.day09;

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

public class Demo08 {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        pool.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    int i = 1 / 0;
                    System.out.println(Thread.currentThread().getName() + " task running");
                } catch (Exception e) {
                    e.printStackTrace();
                    return;
                }
            }
        });
    }
}

3. 线程池处理

package com.dreamer.multithread.day09;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class Demo08 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newFixedThreadPool(1);
        Future<?> result = pool.submit(new Runnable() {
            @Override
            public void run() {
                int i = 1 / 0;
                System.out.println(Thread.currentThread().getName() + " task running");
            }
        });

        TimeUnit.SECONDS.sleep(1);
        // 获取结果的时候，就可以把线程执行任务过程中的异常报出来
        System.out.println(result.get());

    }
}
飞翔荷兰号
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDK线程池和Spring线程池的使用实例解析
08-25
JDK线程池和Spring线程池的使用实例解析 JDK线程池和Spring线程池是两种常用的线程池实现，它们都提供了线程池的功能，但它们在使用和配置上有所不同。下面我们将详细介绍JDK线程池和Spring线程池的使用实例解析。 ...
jdk自带线程池实例详解
08-28
jdk自带线程池实例详解 jdk自带的线程池是Java开发中一个非常重要的概念，特别是在多线程编程中。线程池是线程的容器，每次只执行额定数量的线程，线程池就是用来管理这些额定数量的线程。下面我们来详细了解jdk...
【JDK中提供了哪些线程池】
Java程序员廖志伟
07-19 609
SingleThreadExecutor（单一线程池）：该线程池只有一个线程，确保所有任务都在同一线程中按顺序执行。FixedThreadPool(固定大小线程池)：该线程池的大小固定，不会随着任务数的增加而增加。CachedThreadPool（缓存线程池）：该线程池的大小不固定，可以根据需求自动调整线程池的大小。当池子中的线程都在处理任务时，新的任务会创建新的线程执行。使用线程池的好处包括避免线程的频繁创建和销毁、线程的重用、线程的超时控制、任务队列的缓冲和限制等。
JDK自带线程池和七大参数
weixin_54591579的博客
04-18 376
线程池的七大参数
JDK中线程池（juc编程）
最新发布
2302_79020600的博客
06-16 987
此时就说明线程池中的线程"pool-1-thread-1"被线程池回收了，成为了空闲线程，当我们再次提交任务的时候，该线程就去执行新的任务。当10个工人都有任务在做时，通过控制台的输出，我们可以看到次策略没有通过线程池中的线程执行任务，而是直接调用任务的run()方法绕过线程池直接执行。针对每一个任务，线程池为其分配一个线程去执行，我们可以在第二次提交任务的时候，让主线程休眠一小会儿，看程序的执行结果。通过控制台的输出结果，我们可以看到5个任务是通过1个线程进行执行的,说明此线程池中只存在一个线程对象。
java自定义线程池总结
皓月星辰
06-01 5952
  创建线程池的方法有两种，一种是手动创建，一种是自动创建，本文将分别介绍这两种方式的简单使用。 
JDK中自带的线程池
qq_52350532的博客
11-05 73
核心线程数一个，最大线程数一个，生存时间的0，单位是毫秒 ，使用的任务队列是。不适合并发，可能会引起I/O阻塞，影响线程相应的操作。一、newSingleThreadExecutor(
解析MYSQL行头信息数据详细
热门推荐
张彦峰的博客
10-14 3万+
在数据库管理系统中，理解数据行格式的内部结构对于优化性能和确保数据完整性至关重要。这次我们来探讨一下数据行格式，特别关注行头信息的各个属性，如delete_mask、min_rec_flag、n_owned、heap_no、record_type和next_record等。
自定义实现Java线程池1-模拟jdk线程池执行流程1
08-03
本篇将探讨如何模拟Java的JDK线程池执行流程，以理解其设计原理。核心知识点包括线程池的执行策略、接口设计以及异常处理。 首先，Java中的线程池设计始于JDK 5.0，主要通过`java.util.concurrent`包中的`Executor`...
JDK1.5线程池
04-29
资源很不错
JDK自带的线程池有哪些？
m0_74356429的博客
04-15 303
每种线程池都有其特定的应用场景，选择合适的线程池可以根据任务的特性（如任务的数量、执行时间长短、是否需要周期执行等）来确定。Java JDK 自带的线程池主要包含以下几种类型，这些线程池都是通过。
线程池(一) -- 通过类图简单介绍ThreadPoolExecutor
铭
08-07 745
线程池用起来比较简单，但其内部就像一台仪器，需要各个部分相互协作来完成相应的功能。设计模式就用了工厂模式、策略模式、代理模式以及模板模式。ThreadPoolExecutor类图如下：
线程池总类以及线程池的核心参数简述
辉哥的博客
10-25 1892
JDK自带线程池总类: 1、newFixedThreadPool创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程,如果工作线程数量达到线程池初始的最大数,则将提交的任务存入到池队列中。 2、newCachedThreadPool创建一个可缓存的线程池。这种类型的线程池特点是: 1).工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger.MAX_VALUE...
JDK8线程池-ThreadPoolExecutor动态调整corePoolSize与maximumPoolSize
fenglllle的博客
11-25 1万+
前言 线程池ThreadPoolExecutor在运行的过程中，业务并发量变动，需要不停服务调整线程池的线程数，ThreadPoolExecutor支持动态调整corePoolSize与maximumPoolSize的值。 1. 示例demo public class ThreadChangeTest { public static void main(String[] args)...
任务的批量提交invokeAll两种方法的区别
弹指天下
04-08 3万+
ExecutorService的invokeAll方法有两种用法： 1.exec.invokeAll(tasks) 2.exec.invokeAll(tasks, timeout, unit) 其中tasks是任务集合，timeout是超时时间，unit是时间单位 两者都会堵塞，必须等待所有的任务执行完成后统一返回，一方面内存持有的时间长；另一方面响应性也有一定的影响，毕竟大家都喜欢看看刷
Java的纤程库 - Quasar
程序猿开发日志【学习永无止境】
07-21 2万+
最近遇到的一个问题大概是微服务架构中经常会遇到的一个问题： 服务 A 是我们开发的系统，它的业务需要调用 B 、 C 、 D 等多个服务，这些服务是通过http的访问提供的。 问题是 B 、 C 、 D 这些服务都是第三方提供的，不能保证它们的响应时间，快的话十几毫秒，慢的话甚至1秒多，所以这些服务的Latency比较长。幸运地是这些服务都是集群部署的，容错率和并发支持都比较高，所以不担心它
java高级应用：线程池全面解析
weixin_34018169的博客
08-13 4009
什么是线程池？ 很简单，简单看名字就知道是装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样，通过维护一定数量的线程池来达到多个线程的复用。 线程池的好处 我们知道不用线程池的话，每个线程都要通过new Thread(xxRunnable).start()的方式来创建并运行一个线程，...
jdk线程池与spring线程池
09-06
JDK线程池和Spring线程池都是用于管理和执行多线程任务的工具。它们有一些相似之处，但也有一些区别。 JDK线程池是Java标准库中提供的一个线程池实现，位于`java.util.concurrent`包下。它提供了ThreadPoolExecutor...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值