java中线程池的实现原理：七参、四策

最新推荐文章于 2024-04-20 21:25:11 发布
最新推荐文章于 2024-04-20 21:25:11 发布
阅读量119 收藏
点赞数
分类专栏： Java 文章标签： java 多线程 设计模式 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43074317/article/details/117289862
版权

文章目录

七参-前言

回归最原本的问题，从一个最简单的情况开始，假设有一段代码run() Runnable Thread，你希望异步执行它，怎么写？

new Thread(r).start();//线程创建    销毁--等待GC

这是最简单最直接的写法，我们必须肯定的是：这种写法当然是可以完成功能的。

可是大家都这样写，到处都是这样创建线程的方法，能不能写一个统一的工具类让大家调用呢？发布任务者不用操心谁来做，只需要知道任务结果即可。显得更加优雅一些。

定义一个接口，让各个调用者进行实现

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

第一版 实现类

// 生产者:用户-->Runnable  线程池：线程-->消费tasks
public class ExecutorV1 implements Executor {

    @Override
    public void execute(Runnable command) {
        new Thread(command).start();
    }
}

Doug Lea 在JDK源码注释中给出的就是这样的例子，这是最根本的功能。

虽然此工具类实现了异步执行任务，但是：假设由10000个用户都在调用这个工具类提交任务，那就会创建10000个线程来执行！！

不合适：系统资源开销 对象管理

能不能控制线程的数量？

Executors.newFixedThreadPool(int x)

第二版 实现类

设计一个tasks队列，把所有用户提交的不同需求都给放在这个队列里，然后只启动一个线程，就叫Worker线程，不断从tasks队列中取任务，执行任务。这样无论调用者调用多少次，永远就只有一个Worker线程在运行，如图：

threadpool1

public class ExecutorV2 implements Executor {

    //由调用者提供的阻塞队列
    private final BlockingQueue<Runnable> workQueue;

    public ExecutorV2(BlockingQueue<Runnable> workQueue){
        this.workQueue = workQueue;
        new Thread(new Worker()).start();
    }

    @Override
    public void execute(Runnable command) {
        //直接往队列里放，等着被工作线程们抢
        // Thread1--queue.offer()-->BlockingQueue---queue.take()-->Thread2
        if(!workQueue.offer(command)){ //true   false
            //如果队列满了，直接抛弃
            System.out.println("队列满了，直接抛弃");
        }
    }

    private final class Worker implements Runnable{

        //死循环从队列里读任务，然后运行任务
        @Override
        public void run() {
            Runnable task;
            while(true){
                if((task=getTask())!=null){
                    task.run();
                }
            }
        }

        //堵塞地从队列里获取一个任务
        private Runnable getTask(){
            try {
                return workQueue.take();
            } catch (InterruptedException e) {
                return null;
            }
        }
    }
}

意义有三个：

  1. 控制了线程数量
  2. 队列不但起到了缓冲的作用，还将任务的提交与执行解耦了
  3. 最重要的一点是，解决了每次重复创建和销毁线程带来的系统开销

只有一个后台的工作线程Worker会不会少了点？tasks队列满了怎么办？

第三版 实现类

Worker线程数量增加，但具体数量要让使用者决定，调用时传入，就叫核心线程数corePoolSize

设计思路：

  1. 初始化线程池时，直接启动corePoolSize个工作线程Worker跑着
  2. Worker的任务就是死循环从队列里取任务然后执行
  3. execute方法直接获取任务，把任务放进队列，但队列满了之后直接抛弃

threadpool2

public class ExecutorV3 implements Executor {

    //由调用者提供的阻塞队列
    private final BlockingQueue<Runnable> workQueue;

    public ExecutorV3(int corePoolSize,BlockingQueue<Runnable> workQueue){
        this.workQueue = workQueue;
        //直接创建corePoolSize个线程并启动
        for (int i = 0; i < corePoolSize; i++) {
            new Thread(new Worker()).start();
        }
    }

    @Override
    public void execute(Runnable command) {
        //直接往队列里放，等着被工作线程们抢
        if(!workQueue.offer(command)){
            //如果队列满了，直接抛弃
            System.out.println("队列满了，直接抛弃");
        }
    }

    private final class Worker implements Runnable{

        //死循环从队列里读任务，然后运行任务
        @Override
        public void run() {
           Runnable task;
           while(true){
               if((task=getTask())!=null){
                   task.run();
               }
           }
        }

        //阻塞地从队列里获取一个任务
        private Runnable getTask(){
            try {
                return workQueue.take();
            } catch (InterruptedException e) {
                return null;
            }
        }
    }
}

问题：

  1. 初始化时，创建corePoolSize个线程在那空跑，但没有异步任务提交过来，就有点浪费资源了
  2. 队列一满，直接丢弃任务，有些粗暴，是否让调用者自己决定如何处理

第四版 实现类

  1. 按需创建Worker：刚初始化线程池时，不再立刻创建 corePoolSize 个工作线程，而是等待调用者不断提交任务的过程中，逐渐把工作线程 Worker 创建出来，等数量达到 corePoolSize 时就停止，把任务直接丢到队列里。那就必然要用一个属性记录已经创建出来的工作线程数量，就叫 workCount 。
  2. 加拒绝策略：实现上就是增加一个入参，类型是一个接口 RejectedExecutionHandler，由调用者决定实现类，以便在任务提交失败后执行 rejectedExecution 方法。
  3. 增加线程工厂：实现上就是增加一个入参，类型是一个接口 ThreadFactory，增加工作线程时不再直接 new 线程，而是调用这个由调用者传入的 ThreadFactory 实现类的 newThread 方法。

threadpool3x

public class ExecutorV4 implements Executor {

    // 工作线程的数量
    private AtomicInteger workCount = new AtomicInteger(0);
    // 存放工作线程 Worker 的引用
    private final HashSet<Worker> workers = new HashSet<>();

    // 核心线程数量（超过了就放队列里）
    private volatile int corePoolSize;
    // 由调用者提供的阻塞队列，核心线程数满了之后往这里放
    private final BlockingQueue<Runnable> workQueue;
    // 拒绝策略
    private volatile RejectedExecutionHandler handler;
    // 线程工厂
    private volatile ThreadFactory threadFactory;

    public ExecutorV4(
            int corePoolSize,
            BlockingQueue<Runnable> workQueue,
            RejectedExecutionHandler handler,
            ThreadFactory threadFactory) {
        this.corePoolSize = corePoolSize;
        this.workQueue = workQueue;
        this.handler = handler;
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        if (workCount.get() < corePoolSize) {
            // 工作线程数 <= 核心线程时，新建工作线程
            Worker w = new Worker(command);
            // 增加工作线程数
            workCount.getAndIncrement();
            workers.add(w);
            // 并且把它启动
            w.thread.start();
        } else {
            // 工作线程数 > 核心线程时，放入队列
            if (!workQueue.offer(command)) {
                // 放入队列失败，走拒绝策略
                handler.rejectedExecution(command, this);
            }
        }
    }

    private final class Worker implements Runnable {

        final Thread thread;
        private Runnable task;

        Worker(Runnable firstTask) {
            this.task = firstTask;
            this.thread = threadFactory.newThread(this);
        }

        // 死循环从队列里读任务，然后运行任务
        @Override
        public void run() {
            while (task != null || (task = getTask()) != null) {
                task.run();
                task = null;
            }
        }

        // 阻塞地从队列里获取一个任务
        private Runnable getTask() {
            try {
                return workQueue.take();
            } catch (InterruptedException e) {
                return null;
            }
        }

    }
}

第五版 实现类

问题：

  1. 任务提交频繁
  2. 任务提交不频繁

上述代码是否有问题？

当任务提交量集中爆发，工作线程和队列都被占满了，就只能走拒绝策略，被丢弃掉

threadpool4

解决办法：

设置很大的核心线程数corePoolSize来解决这个问题，是可以的，但是高峰期一般很短暂，为了短暂的高峰设置很大的核心线程数，太浪费资源了。

threadpool5

不够有弹性

弹性思维

设置一个新的属性，最大线程数**maximumPoolSize。当核心线程数和队列都满了时，新提交的任务仍然可以通过创建新的工作线程（叫它非核心线程**），直到工作线程数达到 maximumPoolSize 为止，这样就可以缓解一时的高峰期了，而用户也不用设置过大的核心线程数。

threadpool6

threadpool7

  1. 开始的时候和上一版一样，当 workCount < corePoolSize 时，通过创建新的 Worker 来执行任务。
  2. 当 workCount >= corePoolSize 就停止创建新线程，把任务直接丢到队列里。
  3. 但当队列已满且仍然 workCount < maximumPoolSize 时，不再直接走拒绝策略，而是创建非核心线程，直到 workCount = maximumPoolSize，再走拒绝策略。

corePoolSize 就负责平时大多数情况所需要的工作线程数，而 maximumPoolSize 就负责在高峰期临时扩充工作线程数。

高峰时期的弹性搞定了，那自然就还要考虑低谷时期。当长时间没有任务提交时，核心线程与非核心线程都一直空跑着，浪费资源。我们可以给非核心线程设定一个超时时间 keepAliveTime，当这么长时间没能从队列里获取任务时，就不再等了，销毁线程。

threadpool8

线程池在 QPS 高峰时可以临时扩容，QPS 低谷时又可以及时回收线程（非核心线程）而不至于浪费资源

public class ExecutorV5 implements Executor {
    // 工作线程的数量
    private AtomicInteger workCount = new AtomicInteger(0);
    // 存放工作线程 Worker 的引用
    private final HashSet<Worker> workers = new HashSet<>();

    // 核心线程数量
    private volatile int corePoolSize;
    // 最大线程数
    private volatile int maximumPoolSize;
    // 空闲时间
    private volatile long keepAliveTime;
    // 空闲时间
    private TimeUnit timeUnit;
    // 由调用者提供的阻塞队列，核心线程数满了之后往这里放
    private final BlockingQueue<Runnable> workQueue;
    // 拒绝策略
    private volatile RejectedExecutionHandler handler;
    // 线程工厂
    private volatile ThreadFactory threadFactory;

    public ExecutorV5(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            TimeUnit timeUnit,
            BlockingQueue<Runnable> workQueue,
            RejectedExecutionHandler handler,
            ThreadFactory threadFactory) {
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.keepAliveTime = keepAliveTime;
        this.timeUnit = timeUnit;
        this.workQueue = workQueue;
        this.handler = handler;
        this.threadFactory = threadFactory;
    }

    @Override
    public void execute(Runnable command) {
        if (workCount.get() < corePoolSize) {
            addWorker(command);
            return;
        }
        if (!workQueue.offer(command)) {
            if (workCount.get() < maximumPoolSize) {
                addWorker(command);
                return;
            }
            handler.rejectedExecution(command, this);
        }
    }

    private void addWorker(Runnable command) {
        // 工作线程数 <= 核心线程时，新建工作线程
        Worker w = new Worker(command);
        // 增加工作线程数
        workCount.getAndIncrement();
        workers.add(w);
        // 并且把它启动
        w.thread.start();
    }


    private final class Worker implements Runnable {

        final Thread thread;
        private Runnable task;

        Worker(Runnable firstTask) {
            this.task = firstTask;
            this.thread = threadFactory.newThread(this);
        }

        // 死循环从队列里读任务，然后运行任务
        @Override
        public void run() {
            while (task != null || (task = getTask()) != null) {
                task.run();
                task = null;
            }
            workCount.getAndDecrement();
        }

        // 阻塞地从队列里获取一个任务
        private Runnable getTask() {
            boolean timed = workCount.get() > corePoolSize;
            try {
                return timed ? workQueue.poll(keepAliveTime, timeUnit) : workQueue.take();
            } catch (InterruptedException e) {
                return null;
            }
        }

    }
}

总结

七大核心参数：

  • int corePoolSize：核心线程数
  • int maximumPoolSize：最大线程数
  • long keepAliveTime：非核心线程的空闲时间
  • TimeUnit unit：空闲时间的单位
  • BlockingQueue workQueue：任务队列（线程安全的阻塞队列）
  • ThreadFactory threadFactory：线程工厂
  • RejectedExecutionHandler handler：拒绝策略

整个任务的提交流程：

threadpool9

拒绝策略

当线程池的任务缓存阻塞队列已满，并且线程池中的线程数**workCount== maximunPoolSize**时,如果还有任务提交就会采取拒绝策略。

四种拒绝策略：

都是RejectedExecutionHandler的子类，都是静态内部类，都有两个方法：构造方法、rejectedExecution方法

  1. ThreadPoolExecutor.AbortPolicy【默认的】

    源码

    内部类AbortPolicy注释

    A handler for rejected tasks that throws a RejectedExecutionException.

    一种拒绝任务的处理程序：抛出RejectedExecutionException

    方法rejectedExecution(Runnable r,ThreadPoolExecutor e)注释

    Always throws RejectedExecutionException.

    总是抛出RejectedExecutionException

  2. ThreadPoolExecutor.DiscardPolicy

    源码

    内部类DiscardPolicy注释

    A handler for rejected tasks that silently discards the rejected task.

    一种拒绝任务的处理程序：将自动放弃被拒绝的任务

    方法rejectedExecution(Runnable r,ThreadPoolExecutor e)注释

    Does nothing, which has the effect of discarding task r.

    不执行任何操作，具有丢弃任务r的效果

  3. ThreadPoolExecutor.DiscardOldestPolicy

    源码

    内部类DiscardOldestPolicy注释

    A handler for rejected tasks that discards the oldest unhandled request and then retries execute, unless the executor is shut down, in which case the task is discarded.

    一种拒绝任务的处理程序：丢弃最早的未处理请求，然后重试执行，除非线程池关闭，在这种情况下，任务被丢弃

    方法rejectedExecution(Runnable r,ThreadPoolExecutor e)注释

    Obtains and ignores the next task that the executor would otherwise execute, if one is immediately available, and then retries execution of task r, unless the executor is shut down, in which case task r is instead discarded.

    获取并忽略线程池将执行的下一个任务，如果一个任务立即可用，那么重试执行任务r，除非关闭执行器，在这种情况下，任务r将被丢弃。

  4. ThreadPoolExecutor.CallerRunsPolicy

    源码

    静态内部类CallerRunsPolicy注释

    A handler for rejected tasks that runs the rejected task directly in the calling thread of the execute method, unless the executor has been shut down, in which case the task is discarded.

    一种拒绝任务的处理程序，直接在execute方法的调用线程中运行被拒绝的任务，除非线程池关闭，在这种情况下，该任务被丢弃

    方法rejectedExecution(Runnable r,ThreadPoolExecutor e)注释

    Executes task r in the caller’s thread, unless the executor has been shut down, in which case the task is discarded.

    在调用者的线程中执行任务r，除非线程池已经关闭，在这种情况下，任务被丢弃。

策略选择

1.默认情况

在线程池的具体实现类java.util.concurrent.ThreadPoolExecutor类中，有如下源码：

/**
 * The default rejected execution handler
 */
private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

线程池的默认拒绝策略为AbortPolicy,即丢弃任务并抛出RejectedExecutionException异常。使用代码进行验证：

import java.util.concurrent.*;

public class TestRejectedHandler {
    public static void main(String[] args) {
        //定义一个有界阻塞队列，容量为100
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(100);
        //ThreadFactory是接口，使用Lambda构建对象
        ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
        //创建线程池对象，但唯独不传拒绝策略
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory);
        while (true) {
            //死循环提交任务
            executor.submit(
                    //Lambda构建Runnable实例对象
                    () -> {
                        //run() 核心代码
                        try {
                            System.out.println(queue.size());
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    });
        }
    }
}

运行后，出现如下效果，是符合预期的：

threadPool-Handler-1

2.常用策略CallerRunsPolicy

如果任务被拒绝，则由调用线程（提交任务的线程）直接执行此任务。代码验证:

import java.util.concurrent.*;

public class TestRejectedHandlerDemo2 {
    public static void main(String[] args) {
        //定义一个有界阻塞队列，容量为10
        BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);
        //ThreadFactory是接口，使用Lambda构建对象
        ThreadFactory factory = r -> new Thread(r, "test-thread-pool");
        //创建线程池对象，传CallerRunsPolicy拒绝策略
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5,
                0L, TimeUnit.SECONDS, queue, factory, new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 1000; i++) {
            executor.submit(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + ":执行任务");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

运行后，效果如下：

threadPool-Handler-2

可以看到main线程在执行任务，这正说明了此拒绝策略由调用线程（提交任务的线程）直接执行被丢弃的任务

总结:使用场景

  1. AbortPolicy:线程池默认的拒绝策略，在任务不能再提交的时候，抛出异常，及时反馈程序运行状态。关键的业务，推荐使用此策略，在系统不能承载更大的并发量的时候，能及时的通过异常发现。
  2. DiscardPolicy:丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略。
  3. DiscardOldestPolicy:丢弃队列最前面的任务，然后重新提交被拒绝的任务。是一种喜新厌旧的拒绝策略。是否采用此拒绝策略？根据实际业务是否允许丢弃老任务来抉择
  4. CallerRunsPolicy:由调用线程处理被拒绝的任务

面试题

JDK源码中书写静态内部类的作用

阻塞队列的好处？

现有三个角色：顾客，休息区，银行办理窗口

Thread1为顾客，BlockingQueue为休息区，Thread2为银行办理窗口

  1. 正常情况下，一个银行办理窗口同一时间只能对接一个顾客
  2. 恰巧今天办理的顾客有3个人，另外2个顾客怎么办，你总不至于给人家说不办了，快回家吧
  3. 而正确的做法是你可以让这两个人在休息区等候，等银行窗口空闲了，然后去办理

一个人正在银行办理业务，你后面的人不能打断（保证了原子性），或者争抢（有序性，先进先出），只能在休息区等待，直到上一个人释放资源，才轮到下一个人

问题：

​ 当一个线程占有资源的时候，你后面线程请求不得不阻塞。

但这个也不一定是缺点，反而更像一件好事，因为并不暴力的解决问题。

阻塞定义：

在多线程中，阻塞的意思是，在某些情况下会挂起线程，一旦条件成熟，被阻塞的线程就会被自动唤醒。

阻塞队列的好处：

线程的wait和notify机制不需要自己去手动控制，简化了操作，避免了手动操作容易出现的死锁，逻辑判断等问题。

线程池用了什么设计模式？

线程池模式

策略模式

享元模式

代理模式

秦淏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手写线程池（简化版）
qq_26897321的博客
06-29 2883
要想用好线程池，就得掌握其原理，所欲磨刀不误砍柴工，深入了解线程池的工作原理，对日常工作开发，最重要的是应付面试，哈哈
【手写线程池实现】
祁_z
09-30 417
改为：Runnable poll = workQueue.take();// take()若队列为空，则阻塞线程，直到获取到元素*将：Runnable poll = workQueue.poll();这段代码非常损耗性能，不管队列有没有任务都会一直循环运行。
手写线程池实战
最新发布
2401_84123380的博客
04-20 1019
**线程池默认实现*//** 线程池最大工作者线程数量 *//** 线程池默认工作者线程数量 *//** 线程池最小工作者线程数量 *//** 工作队列，也称任务队列，用来存放客户端提交的任务 *//** 工作者列表，需要具有同步性质，支持并发操作 *//** 工作线程的数量 *//** 线程编号生成器 *//**初始化线程工作者，并启动@param size 初始化工作着大小*/i < size;
手写线程池
qq_42582773的博客
01-28 670
手写线程池
C++多线程编程-手写线程池
xiaoyou137的博客
02-14 571
需要使用支持C++17的编译器编译。
手写JAVA线程池
做笔记\记录遇到的程序bug
07-12 1310
手写JAVA线程池
Java线程池实现原理
itmyhome的专栏
10-17 2264
前言在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其他更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。 第一：降低资源消耗。 第二：提高响应速度。 第三：提高线程的可管理性。
深入理解Java编程线程池的实现原理
08-28
Java中的线程池是通过ThreadPoolExecutor类来实现的，该类继承了AbstractExecutorService类，提供了四个构造方法，可以控制线程池的大小、核心池的大小、最大线程数、线程的存活时间等参数。ThreadPoolExecutor类是...
深入理解Java线程池（PPT：原理+代码）
04-11
通过剖析Java中线程池的原理，解读Java线程池源码，并给出线程池调用的示例，帮助理解线程池的基本原理。
Java concurrency线程池之线程池原理(四)_动力节点Java学院整理
08-30
线程池原理是Java concurrency线程池的核心机制，用于管理线程池中的线程资源。下面将详细介绍Java concurrency线程池之线程池原理。 一、线程池原理 Java concurrency线程池的线程池原理是基于生产者-消费者模型...
Java线程池FutureTask实现原理详解
08-28
Java线程池FutureTask实现原理详解是Java多线程编程中的一种重要机制，用于追踪和控制线程池中的任务执行。下面将详细介绍FutureTask的实现原理。 类视图 为了更好地理解FutureTask的实现原理，我们需要了解一些...
Java手写线程池的实现方法
08-27
主要为大家详细介绍了Java手写线程池的实现方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
自己写的java线程池，学习用，望指点
04-19
NULL 博文链接：https://wentry.iteye.com/blog/1873521
手写线程文档
03-21
大师教你手写线程池pdf ， 希望您早日成为架构师。
Java常用线程池原理及使用方法解析
08-18
Java中的线程池主要由`java.util.concurrent`包下的`ExecutorService`接口及其实现类提供。以下是一些常用的线程池类型： 1. **单一线程池**：`Executors.newSingleThreadExecutor()` 创建的线程池只有一个工作线程...
再手写线程池以及性能分析
weixin_52259848的博客
11-17 477
复用线程资源； 减少线程创建和销毁的开销； 可异步处理生产者线程的任务； 减少了多个任务（不是一个任务）的执行时间；
C++ 手写一个线程池
余识-
07-08 1555
本章要介绍的是线程的进阶版本：线程池。如果你使用过线程，就会知道，每当你想要启用一个任务时，就必须手动去启动一个线程来执行指定的任务。这是很自然的想法，并且也并没有什么不对。当问题就出在，电脑CPU可以同时执行的线程数量并不是无限多的，比如我目前电脑CPU是4核8线程的，意思就是同时最多也只能执行8个线程。如果超过了这个数量，那么CPU就需要不断切换线程，调动资源，让其它线程也能进来运行一会。这个过程相当损耗性能。为了解决这个问题，就有了线程池的概念。
Java手写线程池
qq_32486597的博客
03-10 5066
Java 手写线程池
Java线程池浅析1
08-08
在之前的JAVA LOCK代码浅析中，我们已经讲解过FutureTask的实现原理。它的主要思想是关注任务完成与未完成的状态，任务提交线程可以通过get()方法获取任务的执行结果。 总之，线程池是Java并发编程中的重要组成部分...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值