今天来简单说一下Spring Boot 中的线程池，太好用了！

最新推荐文章于 2024-07-27 22:46:48 发布
最新推荐文章于 2024-07-27 22:46:48 发布
阅读量1.4k 收藏 8
点赞数 3
分类专栏： 为霞而作 SpringBoot+Maven系列 多线程系列 文章标签： spring boot java 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrs_chens/article/details/117767085
版权

📖摘要

今天分享下 ——今天来简单说一下 Spring Boot 中的线程池，太好用了！，欢迎关注！

如果是两张表，先插旧的表，紧接着插新的表，想提高一下插入表的性能优化，一万多条数据就有点慢了。

可以用线程池 ThreadPoolExecutor，首先我用的是 Spring Boot 项目，可以用 Spring 提供的对 ThreadPoolExecutor 封装的线程池 ThreadPoolTaskExecutor，直接使用注解启用。

步骤：

  • 创建 springboot 工程；
  • 创建 Service 层的接口和实现；
  • 创建 controller，开发一个 http 服务接口，里面会调用 service 层的服务；
  • 创建线程池的配置；
  • 将 Service 层的服务异步化，这样每次调用都会都被提交到线程池异步执行；
  • 扩展 ThreadPoolTaskExecutor，在提交任务到线程池的时候可以观察到当前线程池的情况；
  • 如果实际尝试可以用 spring aop 做 showThreadPoolInfo("1. do execute"); 的打印，减少重复代码的出现。

🌂上战座

先创建一个线程池的配置，让 Spring Boot 加载，用来定义如何创建一个 ThreadPoolTaskExecutor，要使用 @Configuration 和 @EnableAsync 这两个注解，表示这是个配置类，并且是线程池的配置类。

Spring Boot 基础就不介绍了，推荐一个大佬的系列教程和示例源码：https://github.com/javastacks/spring-boot-best-practice

/**
 * @Description: 线程池配置类
 * @Author: ChenYongJia
 * @CreateTime: 2021-6-09 09:11:59
 * @Email: chen87647213@163.com
 * @Version: 1.0
 */
@Configuration
@EnableAsync
public class ExecutorConfig {

    private static final Logger logger = LoggerFactory.getLogger(ExecutorConfig.class);

    @Value("${async.executor.thread.core_pool_size}")
    private int corePoolSize;
    @Value("${async.executor.thread.max_pool_size}")
    private int maxPoolSize;
    @Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity;
    @Value("${async.executor.thread.name.prefix}")
    private String namePrefix;

    @Bean(name = "asyncServiceExecutor")
    public Executor asyncServiceExecutor() {
        logger.info("start asyncServiceExecutor");
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(corePoolSize);
        //配置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        //配置队列大小
        executor.setQueueCapacity(queueCapacity);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix(namePrefix);

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
        return executor;
    }
}

@Value 是我配置在 application.properties，可以参考配置，自由定义

# 异步线程配置
# 配置核心线程数
async.executor.thread.core_pool_size = 5
# 配置最大线程数
async.executor.thread.max_pool_size = 5
# 配置队列大小
async.executor.thread.queue_capacity = 99999
# 配置线程池中的线程的名称前缀
async.executor.thread.name.prefix = async-service-

创建一个 Service接口，是异步线程的接口

/**
 * @Description: 异步线程的接口
 * @Author: ChenYongJia
 * @CreateTime: 2021-6-09 09:11:59
 * @Email: chen87647213@163.com
 * @Version: 1.0
 */
public interface AsyncService {

    /**
     * 异步接口
     *
     * @date 2021-6-09 09:13:59
     * @author ChenYongJia
     * @version 1.0
     */
    void executeAsync();
}

实现类：@Async 的作用是让被注解的方法在线程池中执行，至于使用哪个线程池，就看括号中的 asyncServiceExecutor 。(Async 注解用到了 Spring 提供的线程池服务)

/**
 * @Description: 异步线程的接口
 * @Author: ChenYongJia
 * @CreateTime: 2021-6-09 09:14:59
 * @Email: chen87647213@163.com
 * @Version: 1.0
 */
@Service
public class AsyncServiceImpl implements AsyncService {
    private static final Logger logger = LoggerFactory.getLogger(AsyncServiceImpl.class);

	/**
     * 异步实现方法
     *
     * @date 2021-6-09 09:13:59
     * @author ChenYongJia
     * @version 1.0
     */
    @Override
    @Async("asyncServiceExecutor")
    public void executeAsync() {
        logger.info("start executeAsync");

        System.out.println("异步线程的执行内容");
        System.out.println("可以在这里执行批量插入等耗时的事情");

        logger.info("end executeAsync");
    }
}

将 Service 层的服务异步化，在 executeAsync() 方法上增加注解 @Async("asyncServiceExecutor")， asyncServiceExecutor 方法是前面ExecutorConfig.java 中的方法名，表明 executeAsync 方法进入的线程池是 asyncServiceExecutor 方法创建的。

接下来就是在 Controller 里或者是哪里通过注解 @Autowired 注入这个 Service 。

	@Autowired
	private AsyncService asyncService;

	/**
     * 控制器
     *
     * @date 2021-6-09 09:13:59
     * @author ChenYongJia
     * @version 1.0
     */
	@GetMapping("/async")
	public void async(){
    	asyncService.executeAsync();
	}

使用 postman 或者其他工具来多次测试请求一下

2021-06-09 22:15:47.655  INFO 10516 --- [async-service-5] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:15:47.655  INFO 10516 --- [async-service-5] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:15:47.770  INFO 10516 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:15:47.770  INFO 10516 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:15:47.816  INFO 10516 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:15:47.816  INFO 10516 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:15:48.833  INFO 10516 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:15:48.834  INFO 10516 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:15:48.986  INFO 10516 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:15:48.987  INFO 10516 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync

可以发现，[async-service-] 是有多个线程的，显然已经在我们配置的线程池中执行了，并且每次请求中，controller 的起始和结束日志都是连续打印的，表明每次请求都快速响应了，而耗时的操作都留给线程池中的线程去异步执行；

虽然已经用上了线程池，但是还不清楚线程池当时的情况，有多少线程在执行，多少在队列中等待呢？这里我创建了一个 ThreadPoolTaskExecutor 的子类，在每次提交线程的时候都会将当前线程池的运行状况打印出来

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @Description: ThreadPoolTaskExecutor子类用于在每次提交线程的时候都会将当前线程池的运行状况打印出来
 * @Author: ChenYongJia
 * @CreateTime: 2021-6-09 09:14:59
 * @Email: chen87647213@163.com
 * @Version: 1.0
 */
public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);

    private void showThreadPoolInfo(String prefix) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if (null == threadPoolExecutor) {
            return;
        }

        logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",
                this.getThreadNamePrefix(),
                prefix,
                threadPoolExecutor.getTaskCount(),
                threadPoolExecutor.getCompletedTaskCount(),
                threadPoolExecutor.getActiveCount(),
                threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}

如上，showThreadPoolInfo 方法中将任务总数、已完成数、活跃线程数，队列大小都打印出来了，然后 Override 了父类的 execute、submit 等方法，在里面调用 showThreadPoolInfo 方法，这样每次有任务被提交到线程池的时候，都会将当前线程池的基本情况打印到日志中；

修改 ExecutorConfig.java 的 asyncServiceExecutor 方法，将 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor() 改为 ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor()

@Bean(name = "asyncServiceExecutor")
public Executor asyncServiceExecutor() {
    logger.info("start asyncServiceExecutor");
    //在这里修改
    ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
    //配置核心线程数
    executor.setCorePoolSize(corePoolSize);
    //配置最大线程数
    executor.setMaxPoolSize(maxPoolSize);
    //配置队列大小
    executor.setQueueCapacity(queueCapacity);
    //配置线程池中的线程的名称前缀
    executor.setThreadNamePrefix(namePrefix);

    // rejection-policy：当pool已经达到max size的时候，如何处理新任务
    // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    //执行初始化
    executor.initialize();
    return executor;
}

结果如下

2021-06-09 22:23:30.951  INFO 14088 --- [nio-8087-exec-2] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [0], completedTaskCount [0], activeCount [0], queueSize [0]
2021-06-09 22:23:30.952  INFO 14088 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:23:30.953  INFO 14088 --- [async-service-1] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:23:31.351  INFO 14088 --- [nio-8087-exec-3] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [1], completedTaskCount [1], activeCount [0], queueSize [0]
2021-06-09 22:23:31.353  INFO 14088 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:23:31.353  INFO 14088 --- [async-service-2] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:23:31.927  INFO 14088 --- [nio-8087-exec-5] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [2], completedTaskCount [2], activeCount [0], queueSize [0]
2021-06-09 22:23:31.929  INFO 14088 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:23:31.930  INFO 14088 --- [async-service-3] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync
2021-06-09 22:23:32.496  INFO 14088 --- [nio-8087-exec-7] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [3], completedTaskCount [3], activeCount [0], queueSize [0]
2021-06-09 22:23:32.498  INFO 14088 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : start executeAsync
异步线程要做的事情
可以在这里执行批量插入等耗时的事情
2021-06-09 22:23:32.499  INFO 14088 --- [async-service-4] c.u.d.e.executor.impl.AsyncServiceImpl   : end executeAsync

注意

2021-06-09 22:23:32.496  INFO 14088 --- [nio-8087-exec-7] u.d.e.e.i.VisiableThreadPoolTaskExecutor : async-service-, 2. do submit,taskCount [3], completedTaskCount [3], activeCount [0], queueSize [0]

提交任务到线程池的时候，调用的是 submit(Callable task) 方法，当前已经提交了3个任务，完成了3个，当前有0个线程在处理任务，还剩0个任务在队列中等待，线程池的基本情况一目了然。

最后感谢大家耐心观看完毕，留个点赞收藏是您对我最大的鼓励！

🎉最后

  • 更多参考精彩博文请看这里：《陈永佳的博客》

  • 喜欢博主的小伙伴可以加个关注、点个赞哦，持续更新嘿嘿！

陈永佳
关注
专栏目录
springboot创建线程池以及参数解析
hanbingge123的博客
09-05 719
线程池的优势？ 线程池的主要参数？ 线程池流程图 线程池为什么要使用阻塞队列？ 如何配置线程池 Java中提供的线程池 excute方法和submit方法 springboot中通过配置文件及注解创建线程池
Spring Boot整合FTPClient线程池的实现示例
08-26
在本文中，我们将探讨如何在 Spring Boot 项目中整合 FTPClient 线程池的实现示例。FTPClient 是一个常用的 FTP 客户端库，而线程池则可以帮助我们减少频繁创建和销毁 FTPClient 对象带来的性能消耗。 首先，让我们...
SpringBoot配置线程池
YIYIYI
12-16 3231
SpringBoot配置线程池
实战：在Spring Boot中使用线程池
最新发布
为无为，事无事，味无味。
07-27 1368
线程池管理多个线程，但当线程发生异常时，线程池会如何处理这些线程呢？当线程池中的线程遇到异常时，常见的处理策略包括线程销毁和线程复用。线程池是一种管理和复用线程的机制。它预先创建一定数量的线程，当有任务需要执行时，可以从池中取出线程来处理，处理完后再将线程返回池中。Java中的ThreadPoolExecutor默认会销毁异常线程并创建新线程，但开发者可以自定义afterExecute方法来实现复用异常线程的策略。在这个示例中，asyncMethod将会在一个独立的线程中执行，而不是在调用它的线程中。
SpringBoot线程池
盖世英雄~小龙龙的博客
09-29 304
第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源,还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。推荐给大家一个好用免费的文档转换网站。
使用线程池的好处
qq_42093488的博客
08-22 236
线程池的作用： 在程序启动的时候就创建若干线程来响应处理，它们被称为线程池，里面的线程叫工作线程 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 第三：提高线程的可管理性。 常用线程池：ExecutorService 是主要的实现类，其中常用的有 Executors.newSingleThre...
SpringBoot线程池详解含完整示例（值得珍藏）
a342874650的专栏
01-29 2587
Spring Boot中内置了多种线程池，为应用程序提供快速响应和高吞吐量的运行环境。线程池在Spring Boot中起着至关重要的作用，它能够有效地管理和复用线程，降低系统的开销。本文将详细介绍线程池的基本参数、每一种线程池类型的特性，以及常见的拒绝策略。同时，我们将提供完整的源代码和注释，帮助您更好地理解和应用线程池。
Spring Boot使用Spring的异步线程池的实现
08-25
Spring Boot 使用 Spring 的异步线程池的实现 在软件开发中，异步线程池是一种非常重要的技术，能够帮助我们更好地处理系统性能和大用户量请求之间的矛盾。Spring Boot 提供了异步线程池的实现，可以帮助我们更好地...
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
在Spring Boot中，可以使用ThreadPoolTaskExecutor类来创建一个自定义的线程池。例如： ```java @Configuration public class TaskPoolConfig { @Bean("taskExecutor") public Executor taskExecutor() { ...
在spring boot中使用java线程池ExecutorService的讲解
08-26
在 Spring Boot 中使用线程池非常简单，我们可以使用 @Configuration 注解创建一个线程池配置类，然后使用 @Bean 注解创建一个线程池实例。 ``` @Configuration public class ThreadPoolConfig { @Bean public ...
Spring Boot中配置定时任务、线程池与多线程池执行的方法
08-25
总的来说，Spring Boot通过`@EnableScheduling`、`@Scheduled`、`@EnableAsync`和`ThreadPoolTaskExecutor`等工具，为我们提供了灵活的定时任务和线程池配置能力，可以根据实际需求来定制任务执行策略，优化系统性能...
Spring线程池开发实战
何静媛
05-25 7067
作者：chszs，转载需注明。作者博客主页：http://blog.csdn.net/chszs本文提供了三个Spring多线程开发的例子，由浅入深，由于例子一目了然，所以并未做过多的解释。诸位一看便知。前提条件：1）在Eclipse创建一个Java项目，我取名为SpringThreadDemo。2）项目所需的JAR包如图所示： 下面开始。注：项目源码已经托管到GitHub，地址：https://
线程池的好处
dadalan的专栏
10-22 1194
   1、线程不用销毁，管理起来下次调用。     2、可以有看门狗功能，定时监控每个线程的状态。可以精确到代码级，     3、处理线程异常
线程池优点
weixin_46038850的博客
01-19 1134
​ 线程池是一种管理和复用线程资源的机制，它由一个线程池管理器和一组工作线程组成。线程池管理器负责创建和销毁线程池，以及管理线程池中的工作线程。工作线程则负责执行具体的任务。线程池的主要作用是管理和复用线程资源，避免了线程的频繁创建和销毁所带来的开销。线程池包含两个重要的组成部分：线程池大小：指线程池中所能容纳的最大线程数。线程池大小一般根据系统的负载情况和硬件资源来设置。工作队列：用于存放等待执行的任务。当线程池中的工作线程已经全部被占用时，新的任务将被加入到工作队列中等待执行。
线程池结合SpringBoot
m0_61802230的博客
05-09 1221
导读 什么是线程池 线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。 创建线程本身开销大，反复创建并销毁，过多的占用内存。所以有大量线程创建考虑使用线程池。线程池不用反复创建线程达到线程的复用，更具配置合理利用cpu和内存减少了开销，性能会得到提高，还能统一管理任务 比如服务器收到大量请求，每个请求都分配线程去处理，对服务器性能考验就比较大，如果创建5个以上线程考虑使用线程池。 线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等
Java线程池
qq_43238458的博客
11-05 134
一 创建线程的方法 extends Thread implements Runable implements Callable 二 使用线程池的好处 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度：当任务到达时，可以不需要等待线程创建就能立即执行。 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，监控和调优。 二 Executor框架 Executor框架不仅包括了线程池的管理，还提供了线
Spring Boot中一般如何使用线程池？
良月柒
05-07 1071
除了Actuator提供的指标外，我们还可以通过自定义指标来监控线程池的使用情况。例如，可以通过的方法获取到实例，然后通过该实例来获取线程池的各种状态和指标信息。
为什么要用线程池？
javacn_site的博客
05-30 238
线程池是一种管理和复用线程资源的机制，它由一个线程池管理器和一组工作线程组成。线程池管理器负责创建和销毁线程池，以及管理线程池中的工作线程。工作线程则负责执行具体的任务。线程池的主要作用是管理和复用线程资源，避免了线程的频繁创建和销毁所带来的开销。线程池包含两个重要的组成部分：线程池大小：指线程池中所能容纳的最大线程数。线程池大小一般根据系统的负载情况和硬件资源来设置。工作队列：用于存放等待执行的任务。当线程池中的工作线程已经全部被占用时，新的任务将被加入到工作队列中等待执行。
spring boot 自定义线程池
05-17
在Spring Boot中，可以使用Java自带的线程池来创建自定义线程池。创建自定义线程池的步骤如下： 1. 创建一个配置类，用于配置线程池相关参数。 ```java @Configuration public class ThreadPoolConfig { @Bean public ThreadPoolExecutor threadPoolExecutor() { return new ThreadPoolExecutor( 5, // 核心线程数 10, // 最大线程数 60, // 空闲线程存活时间 TimeUnit.SECONDS, // 时间单位 new ArrayBlockingQueue<>(100), // 阻塞队列 new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略 ); } } ``` 2. 在需要使用线程池的地方注入该线程池。 ```java @Service public class UserServiceImpl implements UserService { @Autowired private ThreadPoolExecutor threadPoolExecutor; @Override public void executeTask(Runnable task) { threadPoolExecutor.execute(task); } } ``` 这样，在调用`executeTask()`方法时，就会使用我们自定义的线程池来执行任务。需要注意的是，在使用线程池时，应该避免使用`new Thread()`的方式创建线程，而应该使用线程池来管理线程的生命周期。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陈永佳

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

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

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

打赏作者

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

抵扣说明：

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

余额充值