七： 深入理解Java之线程池

最新推荐文章于 2024-09-18 23:55:52 发布
最新推荐文章于 2024-09-18 23:55:52 发布
阅读量475 收藏
点赞数 1
分类专栏： Java面试 文章标签： java线程池 ThreadPoolExecutor ExecutorService 线程池实现原理 线程池参数讲解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38989232/article/details/103158152
版权

一、JDK线程池的总体api架构：

img

img

img

二、ThreadPoolExecutor类

public class ThreadPoolExecutor extends AbstractExecutorService {
.......
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial parameters and default rejected execution handler.*/
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial parameters and default thread factory.*/
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial parameters.*/
    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参数讲解

  • corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
  • maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
  • keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
  • unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：
 //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

  • workQueue：一保存等待执行的任务的阻塞队列，当提交一个新的任务到线程池以后, 线程池会根据当前线程池中正在运行着的线程的数量来决定对该任务的处理方式，主要有以下几种处理方式:

    1. **SynchronousQueue：**这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
> 
> 2. **LinkedBlockingQueue：内部以一个链式结构(链接节点)对其元素进行存储，如果需要的话这一链式结构可以选择一个上限，如果没有定义上限将使用Integer.MAX_VALUE作为上限**这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
> 
> 3. **ArrayBlockingQueue：一个有界的阻塞队列**可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
> 
> 4. **DelayQueue：**队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
>
> 5.PriorityBlockingQueue:一个无界的并发队列，它使用了和类java.util.PriorityQueue一样的排序规则，你无法向这个队列中插入null值，所有插入到PriorityBlockingQueue的元素必须实现java.lang.Comparable接口。因此该队列中元素的排序就取决于你自己的Comparable实现
>
> 6.LinkedTransferQueue:由链表构成的无界阻塞队列
>
> 7.LinkedBlockingDeque:由链表构成的双向阻塞队列

ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和SynchronousQueue。线程池的排队策略与BlockingQueue有关。

  • threadFactory：线程工厂，主要用来创建线程；
  • handler：它是RejectedExecutionHandler类型的变量，表示线程池的饱和策略。如果阻塞队列满了并且没有空闲的线程，这时如果继续提交任务，就需要采取一种策略处理该任务。线程池提供了4种策略：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

2.2AbstractExecutorService的实现：

public abstract class AbstractExecutorService implements ExecutorService {
 
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
    public Future<?> submit(Runnable task) {};
    public <T> Future<T> submit(Runnable task, T result) { };
    public <T> Future<T> submit(Callable<T> task) { };
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
    };
}

2.3ExecutorService接口的实现：

public interface ExecutorService extends Executor {
 
    void shutdown();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
 
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2.4Executor接口的实现

public interface Executor {
    void execute(Runnable command);
}

到这里，我们就应该明白了ThreadPoolExecutor类、AbstractExecutorService类、ExecutorService接口和Executor接口几个之间的关系了。

Executor是最顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；

ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；

AbstractExecutorService抽象类实现了ExecutorService接口，基本实现了ExecutorService接口中声明的所有方法；

ThreadPoolExecutor类继承了抽象类AbstractExecutorService。

在ThreadPoolExecutor类中有几个非常重要的方法：

    public void execute(Runnable command) {...........}
    public void shutdown() {........}
    public List<Runnable> shutdownNow() {..............}

继承AbstractExecutorService抽象类中的方法

public Future<?> submit(Runnable task) {
　　if (task == null) throw new NullPointerException();
　　　　RunnableFuture<Void> ftask = newTaskFor(task, null);
　　　　execute(ftask);
　　　　return ftask;
}

**execute()**方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。

**submit()**方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果。

shutdown()和shutdownNow()是用来关闭线程池的。

三、深入剖析线程池实现原理

3.1.线程池状态

在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：

volatile int runState; //runState表示当前线程池的状态，它是一个volatile变量用来保证线程之间的可见性
static final int RUNNING    = 0; //当创建线程池后，初始时，线程池处于RUNNING状态；
static final int SHUTDOWN   = 1; //如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；
static final int STOP       = 2; //如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
static final int TERMINATED = 3; //当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

线程池共有五种状态：

thread-pool-executor-status.jpg

状态含义
RUNNING运行状态，该状态下线程池可以接受新的任务，也可以处理阻塞队列中的任务 执行 shutdown 方法可进入 SHUTDOWN 状态 执行 shutdownNow 方法可进入 STOP 状态
SHUTDOWN待关闭状态，不再接受新的任务，继续处理阻塞队列中的任务 当阻塞队列中的任务为空，并且工作线程数为0时，进入 TIDYING 状态
STOP停止状态，不接收新任务，也不处理阻塞队列中的任务，并且会尝试结束执行中的任务 当工作线程数为0时，进入 TIDYING 状态
TIDYING整理状态，此时任务都已经执行完毕，并且也没有工作线程 执行 terminated 方法后进入 TERMINATED 状态
TERMINATED终止状态，此时线程池完全终止了，并完成了所有资源的释放

3.2任务的执行

在了解将任务提交给线程池到任务执行完毕整个过程之前，我们先来看一下ThreadPoolExecutor类中其他的一些比较重要成员变量：

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小、runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集
private volatile long  keepAliveTime;    //线程存货时间   
private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
private volatile int   poolSize;       //线程池中当前的线程数
private volatile RejectedExecutionHandler handler; //任务拒绝策略
private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
private long completedTaskCount;   //用来记录已经执行完毕的任务个数

3.3**.线程池中的线程初始化**

默认情况下，创建线程池之后，线程池中是没有线程的，需要提交任务之后才会创建线程。

在实际中如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：

  • prestartCoreThread()：初始化一个核心线程；
  • prestartAllCoreThreads()：初始化所有核心线程；

3.4**.任务缓存队列及排队策略**

在前面我们多次提到了任务缓存队列，即workQueue，它用来存放等待执行的任务。

workQueue的类型为BlockingQueue<Runnable>，通常可以取下面三种类型：

1）ArrayBlockingQueue：基于数组的先进先出队列，此队列创建时必须指定大小；

2）LinkedBlockingQueue：基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；

3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

3.5任务拒绝策略

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

ThreadPoolExecutor.AbortPolicy //丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy //也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy //丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy //由调用线程处理该任务

3.6线程池的关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：

  • shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
  • shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

3.7线程池容量的动态调整

ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，

  • setCorePoolSize：设置核心池大小
  • setMaximumPoolSize：设置线程池最大能创建的线程数目大小

当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能立即创建新的线程来执行任务。

pool.awaitTermination(1, TimeUnit.SECONDS) 会每隔一秒钟检查一次是否执行完毕（状态为 TERMINATED）

3.8线程池的工作流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afouIVfD-1574218109059)(C:\Users\zhangruilin\AppData\Roaming\Typora\typora-user-images\1555913855312.png)]

3.9合理配置线程池

  • CPU 密集型
    • CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
    • CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。
  • IO 密集型
    • 由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 。
    • 也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。
清风竹雨
关注
专栏目录
深入理解Java之线程池
12-22
在前面的文章中，我们...我们来详细讲解一下Java的线程池，首先我们从核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，后讨论了一下如何合理配置线程池的大小。 　以下是
深入理解Java编程线程池的实现原理
08-28
深入理解Java编程线程池的实现原理 Java中的线程池是通过ThreadPoolExecutor类来实现的，该类继承了AbstractExecutorService类，提供了四个构造方法，可以控制线程池的大小、核心池的大小、最大线程数、线程的存活...
Java并发系列之7 深入理解线程池ThreadPoolExecutor
御风而行
07-07 443
1. 初识线程池 线程池解决了如下两个问题 当执行大量的异步任务时，线程池可以减少每个任务的调用切换开销从而提高应用性能 对执行的线程，和要被执行的任务，提供了管理的方法 此外每个线程池还维护了一些基本统计信息，比如已完成任务的数量 2. ThreadPoolExecutor的简单使用 我们创建一个线程池对象ThreadPoolExecutor，让线程池执行10个打印任务，输出当前任务名称以及...
线程池
qq_36042938的博客
03-23 240
java中提供线程池工具类：java.util.concurrent.Executors提供众多的线程池实现方法 但是，归更到底都是在 new ThreadPoolExecutor对象，ThreadPoolExecutor是线程池的真正实现 java.util.concurrent.Executor 类有子类接口 ExecutorService，抽象类 AbstractExecutorS...
Java多线程编程-（7）-使用线程池实现线程的复用和一些坑的避免
热门推荐
徐刘根的博客
10-16 1万+
前几篇： Java多线程编程-（1）-线程安全和锁Synchronized概念 Java多线程编程-（2）-可重入锁以及Synchronized的其他基本特性 Java多线程编程-（3）-线程本地ThreadLocal的介绍与使用 Java多线程编程-（4）-线程间通信机制的介绍与使用 Java多线程编程-（5）-使用Lock对象实现同步以及线程间通信 Java多线程编程-（6）-两种...
深入理解java之线程池
Dannie的博客
08-21 133
https://www.cnblogs.com/exe19/p/5359885.html
Java线程池：深入理解与高效应用
无远弗届
06-02 943
在多线程编程中，线程的创建和销毁是一个相对昂贵的操作，因为它涉及到操作系统层面的资源分配。线程池提供了一种解决方案，通过复用一组有限的线程来执行多个任务，从而减少了线程创建和销毁的开销。线程池还有助于防止系统过载，因为它可以限制同时运行的线程数量。资源优化：减少频繁创建和销毁线程的开销。提高响应速度：线程可以快速从任务队列中获取任务并执行。提高线程的可管理性：统一管理线程的创建、执行和销毁。控制并发级别：避免过多的线程导致系统过载。自定义线程池允许您通过实现和接口来定制线程的创建和任务的拒绝策略。
剖析线程池：深入理解Java中的线程池构造和调优技巧
逆流的小鱼
04-27 1144
在这个例子中，我们创建了一个核心线程数为4，最大线程数为10，并且非核心线程的存活时间为60秒的线程池。工作队列是容量为100的 LinkedBlockingQueue。当队列满时，执行策略是 AbortPolicy，即抛出 RejectedExecutionException 异常。ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的一个扩展，用于在给定的延迟之后执行命令，或者定期地执行命令。此类是设计为执行线程池中任务的定时或周期性调度。
深入理解 Java 线程池
weixin_42118323的博客
04-22 663
线程池就是存放线程的池子，而池子里的线程可以复用，对线程进行统一调度管理，避免过多线程导致影响到整体的性能。
《深入理解 Java 线程池：高效管理线程的利器》
面团到油条的成长日记
09-18 1131
Java 线程池是一种高效管理线程资源的工具，包括常用类和接口、常见方法、执行流程、配置参数、分类及状态等，应按业务场景选择合适类型并正确配置，同时遵循开发手册通过 ThreadPoolExecutor 方式创建且为线程命名。
深入理解Java 线程池
08-18
深入理解Java线程池 Java 线程池是 Java 编程中一个非常重要的概念，它可以帮助开发者更好地管理和控制线程的执行，提高系统的性能和效率。在 Java 中，线程池是通过 Executor 框架来实现的，Executor 框架提供了...
深入理解Java线程池：ThreadPoolExecutor _ Idea Buffer1
08-03
1. RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务 2. SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保
卷积神经网络程序-matlab
10-03
卷积神经网络程序-matlab-设置基本参数规格，卷积，降采样层，卷积核的大小
利用神经网络实现DNN信号均衡.zip
最新发布
10-03
利用神经网络实现DNN信号均衡
基于文本增强与争议融合的虚假信息检测模型设计源码
10-03
该项目为吉大毕业论文设计源码，主题为基于文本增强与争议融合的虚假信息检测模型。项目包含20个文件，主要包括14个Python源代码文件、2个文本文件、1个Git忽略文件、1个许可证文件、1个Markdown文件、1个JSON文件。该模型旨在提高虚假信息检测的准确性，适用于相关研究与应用场景。
MATLAB 实现的蜜蜂算法优化卷积神经网络（Bee-CNN）进行图像分类预测的详细实例（包含详细的完整的程序和数据）
10-03
内容概要：本文提供了一个基于MATLAB的应用案例来演示蜜蜂算法优化卷积神经网络进行图像识别的具体流程，具体步骤从数据准备、CNN模型构建开始，到用蜜蜂算法优化权值参数、最后是模型训练以及效果评测。附带详尽完整且可以立即使用的源码与实验数据。 适用人群：熟悉 MATLAB 开发环境的基础用户，对图像分类、卷积神经网络及其改进方法有一定理论了解的工程技术人员。 使用场景及目标：该示例适用于初学者掌握MATLAB环境中结合蜜蜂算法改进的卷积神经网路设计技巧、用于解决复杂的图像识别任务。 阅读建议：学习前先确保自己的MATLAB安装完毕并且对基本操作有了解。建议边学习理论边实践尝试修改部分实验参数以便深入了解各个阶段的效果变化。
夏季研究：求解微分方程的神经网络.zip
10-03
夏季研究：求解微分方程的神经网络
Java基础：深入理解线程池与并发控制策略
在Java基础笔记-8-23中，主要探讨了线程池的基础概念及其在并发编程中的应用。线程池是多线程编程中的重要工具，它能够有效地管理和控制线程的生命周期，提高程序的性能和资源利用率。以下是核心要点的详细阐述： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值