Java多线程-线程池

最新推荐文章于 2024-09-22 00:49:10 发布
最新推荐文章于 2024-09-22 00:49:10 发布
阅读量282 收藏
点赞数 1
分类专栏： 多线程 Java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42614447/article/details/88681512
版权

有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程，系统就会不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统消耗就会很大。

使用线程池主要为了解决一下几个问题：

1.通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。
2.对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制等等。

Executor

Executor接口是Executor框架的一个最基本的接口，Executor框架的大部分类都直接或间接地实现了此接口。
Executor接口很简单，只有一个execute方法。

ExecutorService是Executor的子接口，增加了一些常用的对线程的控制方法，之后使用线程池主要也是使用这些方法。
AbstractExecutorService是一个抽象类。ThreadPoolExecutor就是实现了这个类。
在这里插入图片描述
只有一个方法
void execute(Runnable command)： 在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

Executor的几种实现原理介绍：

1、 Executor 接口并没有严格地要求执行是异步的。在最简单的情况下，执行程序可以在调用者的线程中立即运行已提交的任务：

 class DirectExecutor implements Executor {
     public void execute(Runnable r) {
         r.run();
     }
 }
2、 更常见的是，任务是在某个不是调用者线程的线程中执行的。以下执行程序将为每个任务生成一个新线程。

class ThreadPerTaskExecutor implements Executor {
     public void execute(Runnable r) {
         new Thread(r).start();
     }
 }
3、 许多 Executor 实现都对调度任务的方式和时间强加了某种限制。以下执行程序使任务提交与第二个执行程序保持连续，这说明了一个复合执行程序。

 class SerialExecutor implements Executor {
     private final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
     private  final Executor executor;
     Runnable active;

     SerialExecutor(Executor executor) {
         this.executor = executor;
     }

     public synchronized void execute(final Runnable r) {
         tasks.offer(new Runnable() {
             public void run() {
                 try {
                     r.run();
                 } finally {
                     scheduleNext();
                 }
             }
         });
         if (active == null) {
             scheduleNext();
         }
     }

     protected synchronized void scheduleNext() {
         if ((active = tasks.poll()) != null) {
             executor.execute(active);
         }
     }

 }

ExecutorService 接口简介

ExecutorService 是一个接口，提供了管理终止的方法，以及可为跟踪一个或多个异步任务执行状况而生成Future 的方法。
ExecutorService 的实现：

三个实现类：AbstractExecutorService（默认实现类） , ScheduledThreadPoolExecutor, ThreadPoolExecutor
Executors 提供了此接口的几种常用实现的工厂方法。

方法摘要

1. 从Executor 接口中继承了不跟踪异步线程，没有返回的 execute 方法：

void execute(Runnable command)：
在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

2. 扩展的跟踪异步线程、返回Future 接口的实现类的方法：

Future<?> submit(Runnable task)：
提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功 完成时将会返回 null。

<T> Future<T> submit(Runnable task,T result)： 
提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功完成时将会返回给定的结果。

<T> Future<T> submit(Callable<T> task)：
提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。该 Future 的 get 方法在成功完成时将会返回该任务的结果。如果想立即阻塞任务的等待，则可以使用 result = exec.submit(aCallable).get(); 形式的构造

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException:
执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。返回列表的所有元素的 Future.isDone() 为 true。注意，可以正常地或通过抛出异常来终止已完成 任务。如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。

<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：
与 invokeAll的区别是，任务列表里只要有一个任务完成了，就立即返回。而且一旦正常或异常返回后，则取消尚未完成的任务。

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout,TimeUnit unit) throws InterruptedException：
超时等待，同上。

boolean awaitTermination(long timeout,TimeUnit unit) throws InterruptedException：
一直等待，直到所有任务完成。请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行，或者超时时间的到来如果此执行程序终止，则返回 true；如果终止前超时期满，则返回 false

3. 管理生命周期

void shutdown()：
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
List<Runnable> shutdownNow()：
试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。 无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。例如，在 ThreadPoolExecutor 中，通过 Thread.interrupt() 来取消典型的实现，所以如果任务无法响应中断，则永远无法终止。
boolean isShutdown()： 如果此执行程序已关闭，则返回 true。
boolean isTerminated()：
如果关闭后所有任务都已完成，则返回 true。注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。

应用例子：

用法示例

下面给出了一个网络服务的简单结构，这里线程池中的线程作为传入的请求。它使用了预先配置的 Executors.newFixedThreadPool(int) 工厂方法：

class NetworkService implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize)
        throws IOException {
      serverSocket = new ServerSocket(port);
      pool = Executors.newFixedThreadPool(poolSize);
    }
 
    public void run() { // run the service
      try {
        for (;;) {
          pool.execute(new Handler(serverSocket.accept()));
        }
      } catch (IOException ex) {
        pool.shutdown();
      }
    }
  }

  class Handler implements Runnable {
    private final Socket socket;
    Handler(Socket socket) { this.socket = socket; }
    public void run() {
      // read and service request on socket
    }
 }
 


下列方法分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务，然后调用 shutdownNow（如有必要）取消所有遗留的任务：

 void shutdownAndAwaitTermination(ExecutorService pool) {
   pool.shutdown(); // Disable new tasks from being submitted
   try {
     // Wait a while for existing tasks to terminate
     if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
       pool.shutdownNow(); // Cancel currently executing tasks
       // Wait a while for tasks to respond to being cancelled
       if (!pool.awaitTermination(60, TimeUnit.SECONDS))
           System.err.println("Pool did not terminate");
     }
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
   }
 }

ThreadPoolExecutor

ThreadPoolExecutor是线程池的真正实现，他通过构造方法的一系列参数，来构成不同配置的线程池。常用的构造方法有下面四个：

ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue) 

ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory)

ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        RejectedExecutionHandler handler)

ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler)
参数说明
corePoolSize

核心线程数，默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制。除非将allowCoreThreadTimeOut设置为true。

maximumPoolSize

线程池所能容纳的最大线程数。超过这个数的线程将被阻塞。当任务队列为没有设置大小的LinkedBlockingDeque时，这个值无效。

keepAliveTime

非核心线程的闲置超时时间，超过这个时间就会被回收。

unit

指定keepAliveTime的单位，如TimeUnit.SECONDS。当将allowCoreThreadTimeOut设置为true时对corePoolSize生效。

workQueue

线程池中的任务队列.
常用的有三种队列，SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

threadFactory

线程工厂，提供创建新线程的功能。ThreadFactory是一个接口，只有一个方法

public interface ThreadFactory {
  Thread newThread(Runnable r);
}

通过线程工厂可以对线程的一些属性进行定制。

默认的工厂：

static class DefaultThreadFactory implements ThreadFactory {
  private static final AtomicInteger poolNumber = new AtomicInteger(1);
  private final ThreadGroup group;
  private final AtomicInteger threadNumber = new AtomicInteger(1);
  private final String namePrefix;

  DefaultThreadFactory() {
      SecurityManager var1 = System.getSecurityManager();
      this.group = var1 != null?var1.getThreadGroup():Thread.currentThread().getThreadGroup();
      this.namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
  }

  public Thread newThread(Runnable var1) {
      Thread var2 = new Thread(this.group, var1, this.namePrefix + this.threadNumber.getAndIncrement(), 0L);
      if(var2.isDaemon()) {
          var2.setDaemon(false);
      }

      if(var2.getPriority() != 5) {
          var2.setPriority(5);
      }

      return var2;
  }
}
RejectedExecutionHandler

RejectedExecutionHandler也是一个接口，只有一个方法

public interface RejectedExecutionHandler {
  void rejectedExecution(Runnable var1, ThreadPoolExecutor var2);
}

当线程池中的资源已经全部使用，添加新线程被拒绝时，会调用RejectedExecutionHandler的rejectedExecution方法。

线程池规则

线程池的线程执行规则跟任务队列有很大的关系。

下面都假设任务队列没有大小限制：
  1. 如果线程数量<=核心线程数量，那么直接启动一个核心线程来执行任务，不会放入队列中。
  2. 如果线程数量>核心线程数，但<=最大线程数，并且任务队列是LinkedBlockingDeque的时候，超过核心线程数量的任务会放在任务队列中排队。
  3. 如果线程数量>核心线程数，但<=最大线程数，并且任务队列是SynchronousQueue的时候，线程池会创建新线程执行任务，这些任务也不会被放在任务队列中。这些线程属于非核心线程，在任务完成后，闲置时间达到了超时时间就会被清除。
  4. 如果线程数量>核心线程数，并且>最大线程数，当任务队列是LinkedBlockingDeque，会将超过核心线程的任务放在任务队列中排队。也就是当任务队列是LinkedBlockingDeque并且没有大小限制时，线程池的最大线程数设置是无效的，他的线程数最多不会超过核心线程数。
  5. 如果线程数量>核心线程数，并且>最大线程数，当任务队列是SynchronousQueue的时候，会因为线程池拒绝添加任务而抛出异常。
任务队列大小有限时
  1. 当LinkedBlockingDeque塞满时，新增的任务会直接创建新线程来执行，当创建的线程数量超过最大线程数量时会抛异常。
  2. SynchronousQueue没有数量限制。因为他根本不保持这些任务，而是直接交给线程池去执行。当任务数量超过最大线程数时会直接抛异常。

规则验证

所有的任务都是下面这样的，睡眠两秒后打印一行日志：

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " run");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
};

所有验证过程都是下面这样，先执行三个，再执行三个，8秒后，各看一次信息

executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---先开三个---");
System.out.println("核心线程数" + executor.getCorePoolSize());
System.out.println("线程池数" + executor.getPoolSize());
System.out.println("队列任务数" + executor.getQueue().size());
executor.execute(myRunnable);
executor.execute(myRunnable);
executor.execute(myRunnable);
System.out.println("---再开三个---");
System.out.println("核心线程数" + executor.getCorePoolSize());
System.out.println("线程池数" + executor.getPoolSize());
System.out.println("队列任务数" + executor.getQueue().size());
Thread.sleep(8000);
System.out.println("----8秒之后----");
System.out.println("核心线程数" + executor.getCorePoolSize());
System.out.println("线程池数" + executor.getPoolSize());
System.out.println("队列任务数" + executor.getQueue().size());
验证1
  1. 核心线程数为6，最大线程数为10。超时时间为5秒
ThreadPoolExecutor executor = new ThreadPoolExecutor(6, 10, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

---先开三个---
核心线程数6
线程池线程数3
队列任务数0
---再开三个---
核心线程数6
线程池线程数6
队列任务数0
pool-1-thread-1 run
pool-1-thread-6 run
pool-1-thread-5 run
pool-1-thread-3 run
pool-1-thread-4 run
pool-1-thread-2 run
----8秒之后----
核心线程数6
线程池线程数6
队列任务数0

可以看到每个任务都是是直接启动一个核心线程来执行任务，一共创建了6个线程，不会放入队列中。8秒后线程池还是6个线程，核心线程默认情况下不会被回收，不收超时时间限制。

验证2

  1. 核心线程数为3，最大线程数为6。超时时间为5秒,队列是LinkedBlockingDeque
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());

---先开三个---
核心线程数3
线程池线程数3
队列任务数0
---再开三个---
核心线程数3
线程池线程数3
队列任务数3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之后----
核心线程数3
线程池线程数3
队列任务数0

当任务数超过核心线程数时，会将超出的任务放在队列中，只会创建3个线程重复利用。

验证3

  1. 核心线程数为3，最大线程数为6。超时时间为5秒,队列是SynchronousQueue
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

---先开三个---
核心线程数3
线程池线程数3
队列任务数0
---再开三个---
核心线程数3
线程池线程数6
队列任务数0
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-6 run
pool-1-thread-4 run
pool-1-thread-5 run
pool-1-thread-1 run
----8秒之后----
核心线程数3
线程池线程数3
队列任务数0

当队列是SynchronousQueue时，超出核心线程的任务会创建新的线程来执行，看到一共有6个线程。但是这些线程是费核心线程，收超时时间限制，在任务完成后限制超过5秒就会被回收。所以最后看到线程池还是只有三个线程。

验证4

  1. 核心线程数是3，最大线程数是4，队列是LinkedBlockingDeque
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 5, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());

---先开三个---
核心线程数3
线程池线程数3
队列任务数0
---再开三个---
核心线程数3
线程池线程数3
队列任务数3
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
pool-1-thread-3 run
pool-1-thread-1 run
pool-1-thread-2 run
----8秒之后----
核心线程数3
线程池线程数3
队列任务数0

LinkedBlockingDeque根本不受最大线程数影响。
但是当LinkedBlockingDeque有大小限制时就会受最大线程数影响了

转载请注明出处！

梦和远方
关注
专栏目录
java多线程-线程池ThreadPoolExecutor构造方法和规则
9.冄2.7.號的博客
08-30 218
为什么用线程池 有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统就不一定能受得了。 使用线程池主要为了解决以下几个问题： 通过重用线程池中的线程，来减少每个线程创建和销毁的性能开销。 对线程进行一些维护和管理，比如定时开始，周期执行，并发数控制等等。 Executor Executor是一个接口，跟线程池有关的基本都要跟它打交道，。下面是常用得我Thre
java多线程与线程池-03线程池与阻塞队列
天空鸟的博客
03-10 974
队列是一种特殊的集合，一般队列都具有先进先出（FIFO）的特性（并不绝对要求）。优先级队列（PriorityQueue）按照元素的比较方法排序，其他队列基本采用自然序排队。队列Queue接口实现了Collection接口，offer()方法负责把元素插入队列中。peek()方法检索队列头是否存在元素（不移除元素），poll()方法则是检索并移除元素。当队列为空时，peek()和poll()方法都返回null。BlockingQueue为阻塞队列接口，它继承了Queue接口。BlockingQueue接口中新
Java多线程---线程池
卿霜寒墨的博客
09-12 249
线程池 Executors 在之后的Java开发中，我们会不可避免的创建大量线程，线程完成任务后就被销毁了，这种情况下，线程执行任务的流程是创建线程，创建任务，执行任务，关闭线程，而创建和释放线程会占据整个流程的多数时间。如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。 一个线程池包括以下四
Java多线程及原理
javaDB_EAD的专栏
09-12 440
java线程池及原理
Java多线程（六）：线程池详解
最新发布
2401_87254608的博客
09-22 372
【代码】Java多线程（六）：线程池详解。
Java多线程之线程池
m0_54828003的博客
08-13 259
在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多得多。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。...
java多线程之线程池
程序三两行
06-30 4479
在执行一个异步任务或并发任务时，往往是通过直接new Thread()方法来创建新的线程，这样做弊端较多，更好的解决方案是合理地利用线程池，线程池的优势很明显，如下： 降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗...
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
线程-线程池-锁-集合-Map-队列.docx
05-18
线程的状态管理是多线程编程中非常重要的部分。Java线程有六种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED。NEW表示线程刚创建还未启动，RUNNABLE表示线程在执行或等待CPU资源，BLOCKED表示...
Java多线程并发-线程池-CompletableFuture
Juinjonn的博客
03-03 3076
线程的工作模式是，首先先要创建线程并指定线程需要执行的业务方法，然后再调用线程的 start() 方法，此时线程就从 NEW（新建）状态变成了 RUNNABLE（就绪）状态，此时线程会判断要执行的方法中有没有 synchronized 同步代码块，如果有并且其他线程也在使用此锁，那么线程就会变为 BLOCKED（阻塞等待）状态，当其他线程使用完此锁之后，线程会继续执行剩余的方法。
java多线程（线程池）
姜虹影的博客
10-28 1776
线程池 ​ 管理线程的资源池，可以复用线程，不用频繁的创建新线程，节省线程开销的资源损耗，节省资源，提高响应速度。主要概念：核心线程、阻塞队列、非核心线程、空闲时间、饱和策略。 ​ 线程池执行过程 Created with Raphaël 2.2.0提交任务核心线程池是否已满？阻塞队列(:任务队列)是否已满？线程池是否已满（是否可以创建非核心线程）？饱和策略创建非核心线程执行任务任务添加到阻塞队列创建核心线程执行任务yesnoyesnoyesno JUC线程管理 ThreadPoolExecutor 《阿
【Java多线程】线程池
ChrisLee2013的博客
07-19 312
*** 执行线程 具体由子类实现corePoolSize：核心线程数maximumPoolSize：最大线程数keepAliveTime：当线程数超过核心线程数后，非核心线程的保持活性时间unit：活性时间单位workQueue：工作队列threadFactory：线程工厂handler：拒绝策略。
Java 多线程：线程池
提辖鲁的博客
02-25 863
Java 线程池：ThreadPoolExecutor线程池当需要频繁的创建多个线程进行耗时操作时,频繁创建和销毁线程对象性能较差,并且缺乏统一管理,可能会无限制创建线程,导致相互竞争资源导致死锁,因此使用线程池就可以创建多个线程并且进行管理,提交的任务会被线程池指派给其中的线程进行执行,通过线程池的统一调度和管理使得多线程的使用更简单高效。线程池的优点 重用线程池中的线程,避免因为线程的创建和销毁
java多线程---线程池
阿七
07-29 268
1.基本架构 Executors和arrays,collections一样，是一个工具类。，那么底层核心在ThreadPoolExecutor上面。 2.实现 有5种实现，重点3种：通过executors获得。 （同时，第四种获得java多线程的方式，线程池，第三种是通过callable,其余两种thread,runable) 1.fixedThreadPool() ，固定装载的线程数量。 里面使用了一个LinkedBlockQueue，有最大线程数量，如果来的请求了超过了线程池的最
Java多线程——线程池
qq_51774011的博客
07-09 3304
本文详细介绍了关于java线程池的相关知识点，主打一个详细面面俱到！
Java_多线程：线程池
2401_83326044的博客
07-02 2340
线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
java多线程配置线程池
08-16
在Java多线程编程中，配置线程池的参数是非常重要的。根据不同的业务需求，可以设置线程池的参数来控制线程的数量和行为。根据引用中的例子，可以使用`Executors.newFixedThreadPool(int nThreads)`来创建一个固定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值