JUC并发编程---ThreadPoolExecutor线程池的状态、机制与原理源码解读

已于 2024-03-28 11:38:31 修改
阅读量3.1k 收藏 2
点赞数 2
分类专栏： Java 文章标签： java
于 2019-09-06 12:50:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/odeviloo/article/details/100543408
版权

关键变量

  • corePoolSize：核心线程数量 在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法。
  • maximumPoolSize：最大线程数量 线程池最大线程数
  1. 如果池中的实际线程数小于corePoolSize,无论是否其中有空闲的线程，都新建worker去执行此次任务
  2. 如果池中的线程数>=corePoolSize提交到队列，如果队列已满则新建worker去执行任务
  3. 如果池中的线程数＝maximumPoolSize且队列已满，则执行拒绝策略。
  • allowCoreThreadTimeOut：是否允许核心线程超时(设置为true时与keepAliveTime，TimeUnit一起起作用，worker数量可能降为0)
  • keepAliveTime：线程存活时间(当线程池允许线程超时且运行中的线程数量超过corePoolSize时，会按照此变量设置时间关闭线程)

线程池状态

ctl：表示线程池状态，1、workCount 有效任务线程数 2、runState 运行状态 关闭还是运行

  • workCount：表示允许启动不许停止的线程数，即运行中线程数。其值瞬态与实际存活线程数不同，比如当任务提交时，线程工厂创建一个线程失败，退出线程在结束之前能在执行bookkeeping（记录）。用户可见的线程池数量用作当前任务线程数量。为了将两个值放入一个int变量，限制了workerCount 上线2^29-1 而不是2^31-1。
  • runState：提供主要的声明周期控制，有一下值
  1. RUNNING：接受新的任务，处理队列任务；
  2. SHUTDOWN：不再接受新的任务，继续处理队列任务；
  3. STOP：不再接受新任务，不处理队列任务，尝试中断正在执行的任务线程；
  4. TIDYING：所有的任务已经结束，任务线程为0，线程转换到TIDYING；
  5. TERMINATED：线程池已结束，即terminated()方法执行完
    在这里插入图片描述

线程池创建

// 直接使用构造函数
new ThreadPoolExecutor(coreSize, maxSize, keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

// 创建一个固定线程数量的线程池，可控制线程最大并发数，超出的任务会在队列中等待。
Executors.newFixedThreadPool(4);
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

// 此线程池只有一个线程，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
Executors.newSingleThreadExecutor();
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

// 存线程池内线程数量会随时变化，当空闲线程不足则启用新线程，如果相对空闲，闲置线程会被回收
Executors.newCachedThreadPool();
public static ExecutorService newCachedThreadPool() {
	return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

// 固定线程数的线程池，支持定时及周期性任务执行。
Executors.newScheduledThreadPool(4);
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
	return new ScheduledThreadPoolExecutor(corePoolSize);
}

任务提交流程

// ThreadPoolExecutor 继承于 AbstractExecutorService
public class ThreadPoolExecutor extends AbstractExecutorService

// 如果要提交任务需要调用 AbstractExecutorService 的 submit方法
executor.submit(new MyRunnable());

整体的提交流程如下图所示：
在这里插入图片描述

AbstractExecutorService的submit方法

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    // 将任务转为 FutureTask
    RunnableFuture<Void> ftask = newTaskFor(task, null); 
    // 调用自己的execute，也就是ThreadPoolExecutor的execute
    execute(ftask); 
    return ftask;
}

ThreadPoolExecutor的execute

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();
    // 当前运行的线程数小于核心线程数，创建新的worker并将提交的任务作为其首个任务
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 如果线程数大于coreSize或者创建worker失败了
    // 比如workerCount = 1 coreSize = 2 并发调用addWorker 则有一个会失败
    // 且线程池还是运行状态，且队列添加任务成功
    if (isRunning(c) && workQueue.offer(command)) {
    	// 如果线程池状态变了（非运行状态）就需要从队列移除任务
        int recheck = ctl.get();
        if (!isRunning(recheck) && remove(command))
            reject(command); // 移除成功则执行拒绝策略
        // 如果线程为0，则新建一个线程，比如上面的CachedThreadPool中coreSize为0
        // 不会去创建核心线程，所以在这里创建线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 线程数量超过了corePoolSize，并且队列已满
    // 创建新的worker执行当前任务，如果worker已经超过max，则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

addWorker方法

/**
 * firstTask：如果不为空，则应该为创建的线程先执行的任务。
 * 对于少于核心线程数的情况或者队列已满，可以用firstTask来绕过队列，让线程直接执行。
 * 
 * core：判断的时候使用核心线程数还是最大线程数
 */
 // 代码过多，省略部分源码
private boolean addWorker(Runnable firstTask, boolean core) {
    // 下面省略的代码主要目的是判断下线程池状态，并且尝试增加workCount的值，
    // ......
    try {
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            try {
				// 将新建的worker加入workers
                if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            }
            if (workerAdded) { // 如果worker添加成功，则启动内部线程
                t.start(); 
                workerStarted = true;
            }
        }
    } finally {
        if (!workerStarted) // 如果上面线程启动失败则从workers移除worker
            addWorkerFailed(w);
    }
    return workerStarted; // 返回worker是否成功启动
}

任务的处理

上面都只是说了worker的创建，但是都没有说任务什么时候去执行下面就看看任务怎么处理的

worker继承AbstractQueuedSynchronizer主要用于处理并发问题
实现Runnable主要为了实现run方法以方便外部调用
private final class Worker extends AbstractQueuedSynchronizer
        implements Runnable {
	final Thread thread; // 内部的线程
	Runnable firstTask; // 首个任务，可能为空
	volatile long completedTasks; // 完成任务数
	Worker(Runnable firstTask) {
       setState(-1); // inhibit interrupts until runWorker
       this.firstTask = firstTask;
       // 使用ThreadFactory新建线程并将自己作为参数传入（自己实现Runnable接口）
       // 调用thread.start()会执行下面的run方法
       this.thread = getThreadFactory().newThread(this);
   }
}

主要的实现方法

// run比较简单 调用自己的方法
public void run() {
	runWorker(this);
}
// 主要的处理逻辑
final void runWorker(Worker w) {
  	// 如果有firstTask 则task = firstTask 且将firstTask = null
	Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
    	// 如果task为空 则阻塞 尝试从队列获取任务
    	// 如果超过keepAliveTime或线程池已经SHUTDOWN则返回空
        while (task != null || (task = getTask()) != null) {
        	// 源码看着真难受，主要是为了满足下面两个情况，把下面情况代入是通的。
        	// 如果状态是SHUTDOWN，会修改中断状态，继续跑完所有任务
            // 1. 线程池停了，确保线程中断
            // 2. 如果没停，确保线程没有中断
            if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() 
            	&& runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted())
                wt.interrupt();
            try {
            	// 空方法 可以根据业务自己继承实现
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    task.run(); // 执行真正的业务逻辑
                } finally {
                	// 空方法 可以根据业务自己继承实现
                    afterExecute(task, thrown);
                }
            }
        }
        completedAbruptly = false;
    } finally {
    	// 如果上面代码没有正常执行 completedAbruptly = true
    	// processWorkerExit 将 worker从workers里面移除 尝试结束线程池
        processWorkerExit(w, completedAbruptly);
    }
}

看看任务是如何获取的

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 如果线程池已经关闭或者任务队列已经为空 减小worker的数量 返回NULL
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount(); 
            return null;
        }

        int wc = workerCountOf(c);
		// 如果允许核心线程超时或者当前线程数大于核心线程数
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        // 如果当前线程数大于最大线程数 或者 已经超时 且 有启动的线程 或 任务为空
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
        	// 是否限制超时时间 如果有 则尝试获取任务等待keepAliveTime 否则尝试获取任务
        	// 如果超时了，设置timedOut为true，上面代码就可能返回null
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

队列类型

workQueue：缓冲队列，队列类型

  1. ArrayBlockingQueue：基于数组结构的有界阻塞队列，必须制定最大任务数，此队列按 FIFO（先进先出）原则对元素进行排序。
  2. LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于 ArrayBlockingQueue。使用LinkedBlockingQueue如果不指定大小，默认队列长度会设置为Integer.MAX_VALUE，静态工厂方法Executors.newFixedThreadPool()使用了这个队列。当任务执行时间较长，且任务数量较多时，可能导致任务堆积过多而内存溢出。
  3. SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
  4. PriorityBlockingQueue：一个具有优先级的无限阻塞队列

拒绝策略

当maxPoolSize达到最大，任务数量任在继续增加，线程池处理能力达到最大，无法继续接受新任务，会拒绝接受新任务，调用指定的 RejectedExecutionHandler 来执行

final void reject(Runnable command) {
   handler.rejectedExecution(command, this);
}

AbortPolicy：直接抛出RejectedExecutionException异常，默认。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
	throw new RejectedExecutionException("Task " + r.toString() +
                                        " rejected from " +
                                        e.toString());
}

CallerRunsPolicy：只用调用者所在线程来运行任务。由于饱和，下个任务会由调用execute的线程执行，由于任务提交线程需要去执行任务，那么此线程不会提交新任务，因此请求保存在TCP层的队列而不是线程池队列

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if(!e.isShutdown()) {
    	// submit->execute->reject都是由提交任务的线程执行的
    	// 所以r里面的具体逻辑也是由其处理
        r.run(); 
    }
}

DiscardOldestPolicy：丢弃队列里最早的一个任务，并让线程池执行这个任务

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        e.getQueue().poll();
        e.execute(r); // 交由线程池去执行，重新跑一遍execute
    }
}

DiscardPolicy：不处理，丢弃掉。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}

关闭线程池

1. shutdown

public void shutdown() {
    finalReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN); // 循环将状态更新为SHUTDOWN
        interruptIdleWorkers(); // 尝试调用所有线程的interrupt()方法
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate(); // 尝试 修改为 TIDYING -> TERMINATED
}
  1. 修改线程池为SHUTDOWN状态
  2. 将线程池中的线程中断
  3. 尝试将线程池终止

如果这个时候提交任务，不会放入队列，而是直接执行拒绝策略。从上文runWorker方法的源码可以看到，线程不会立即终止，而是等到所有任务跑完才会进入中断。

2. shutdownNow

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP); // 将状态修改为STOP
        interruptWorkers(); 
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}
  1. 修改状态为STOP
  2. 中断线程
  3. 返回任务队列中的任务

同上，如果这个时候提交任务，不会放入队列，而是直接执行拒绝策略。从上文runWorker方法的源码可以看到，空闲线程如果这个时候去获取任务会调用interrupt，并且可以执行完这个任务，但是下次将获取不到这个任务而退出循环。

问题

1. lambda导致任务不执行

private class LaunchTask implements Runnable {
		public LaunchTask() {
			System.out.println(1);
		}

		@Override
        public void run() {
        	System.out.println(2);
        }
}

// 原来的提交方式
submit(LaunchTask::new);

这种方法会导致LaunchTask的run方法不执行，而只会执行LaunchTask的构造方法。造成此问题主要原因还是自己对lambda不熟悉，目前理解LaunchTask::new会创建一个labmda类型，其run方法包装LaunchTask的构造方法而不是LaunchTask的run方法。

写代码的克总
关注
专栏目录
JUC学习 - 深入剖析线程池（ThreadPoolExecutor）（补）
TyuIn的博客
12-05 661
接上一篇博客 https://blog.csdn.net/qq_43605444/article/details/121727738?spm=1001.2014.3001.5501 6、Worker 类 下面的是在 Worker 类上的官方的一段注释： /** * Class Worker mainly maintains interrupt control state for * threads running tasks, along with other minor bookkeeping.
JUC Executor-ThreadPoolExecutor（线程池） 源码解析
淦淦淦！
03-04 447
通过Java并发编程实战（进阶篇 - 下）对 Executor 框架的简介，已经基本了解了 Executor 框架的结构和成员，本篇讲解 Executor 框架中任务执行单元 ThreadPoolExecutor（线程池）工作原理。 前言 提出三个问题来更好的了解 ThreadPoolExecutor： 什么是线程池？ 线程池是指在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行...
JUC并发编程与源码分析视频课.zip
12-16
网盘文件永久链接
JUC并发编程与源码分析(1)
qq_43478625的博客
11-01 1724
JUC并发编程与源码分析JUC四大口诀为什么多线程极其重要？一、线程基础知识1.1 线程的start方法1.2 线程相关概念1.2.1 进程1.2.2 线程何为进程和线程1.2.3 管程Monitor(监视器),也就是我们平时所说的锁1.3 用户线程和守护线程代码二、CompletableFuture2.1 Future和Callable接口2.2 FutureTask2.2.1 Future接口相关架构2.2.2. get()阻塞代码2.2.3 isDone()轮询 JUC四大口诀 高内聚低耦合前提下，
记录 ThreadPoolExecutor的一些细节
最新发布
Ljj_fishhG的博客
09-09 247
方法执行前执行，事实并非如此，实际上，execute 方法是线程池对外提供的主要方法，用于提交任务到线程池中执行，而beforeExecute 方法则是在任务真正被执行之前由线程池调用的回调方法。而其有三种提交任务方式：add、put和offer，好奇其内部用的哪个，又不想查资料，故而跳到源码内部一看。若只看方法名，或许会以为。
尚硅谷JUC并发编程与源码分析
一个沉迷Java，无法自拔的Coder
07-07 696
深入理解JUC并发编程
JUC并发编程 - ReentrantReadWriteLock源码分析
技术架构公社
08-22 326
前言 ReentrantReadWriteLock锁是AQS的另一种实现，它做到了可重入、可中断，分为公平和非公平两类实现，并且实现了读锁和写锁两类同时控制。在使用时，读写锁持有的同一个Lock实例，通过控制锁的行为，及CLH节点状态，来操作读锁和写锁，对于写少读多的场景，能提高效率。 由于我对AQS及ReentrantLock的源码已经做过分析，因此本篇文章对经常出现的代码流程介绍的会较为粗略，初次接触ReentrantReadWriteLock源码的同学，建议先从前面的文章看起，这样反而更能清晰的理
JUC并发编程与源码分析(5)
qq_43478625的博客
11-28 574
JUC并发编程与源码分析一、ThreadLocal1.1 是什么?1.2 能干嘛?1.3 api介绍1.4 入门案例1.5 ThreadLocal源码分析Thread，ThreadLocal，ThreadLocalMap 关系Thread和ThreadLocalThreadLocal和ThreadLocalMap三者总概括小总结1.6 ThreadLocal内存泄漏问题什么是内存泄漏?回顾ThreadLocalMap强软弱虚四大引用整体架构强引用软引用弱引用虚引用GCRoots和四大引用小总结为什么要用弱引
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 916
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
【JUC】线程池-ThreadPoolExecutor源码解析
aaa_bbb_ccc_123_456的博客
12-26 2525
1.线程池能做什么？ 是控制运行的线程的数量 处理过程中将任务加入队列,然后在线程创建后启动这些任务 如果先生超过了最大数量,超出的数量的线程排队等候 等其他线程执行完毕,再从队列中取出任务来执行. 简单来说，线程池可以管理线程，进行线程复用和控制最大并发数。 2.线程池优点？ 第一:降低资源消耗.通过重复利用自己创建的线程降低线程创建和销毁造成的消耗. 第二: 提高响应速度.当任务到...
JUC并发编程与源码分析(6)
qq_43478625的博客
12-01 513
JUC并发编程与源码分析一、AQS(AbstractQueuedSynchronizer) 抽象队列同步器1.1 是什么?1.2 AQS为什么是JUC内容中最重要的基石1.2.1 和AQS有关的1.2.2 进一步理解锁和同步器的关系锁，面向锁的使用者同步器，面向锁的实现者1.3 能干嘛?1.4 AQS初步1.4.1 AQS初识官网解释有阻塞就需要排队，实现排队必然需要队列1.4.2 AQS内部体系架构1.4.2.1 AQS的int变量1.4.2.2 AQS的CLH队列1.4.2.3 小总结1.4.2.4 内
JUC并发编程 - ReentrantLock源码分析
技术架构公社
04-15 313
前言 前面分析了AQS类的源码，但真正实现AQS的实现类都在JUC中，当然AQS也是JUC的一部分，只是它不面向应用，除非自己去继承实现一套逻辑。 在java的java.util.concurrent包，简称JUC，其内包含的类都与多线程有关，是非常重要的一个包。接下来准备针对JUC下常用类进行分析，剖析它们的原理及使用特点。而本文将针对比较常用的ReentrantLock源码来分析。 Re...
JUC并发编程——CAS 介绍及底层源码分析
万里顾一程的博客
09-29 360
文章目录JUC并发编程——CAS 介绍及底层源码分析1、什么是 CAS2、JDK 对 CAS 的支持3、原子类操作源码分析4、原子引用解决ABA问题 JUC并发编程——CAS 介绍及底层源码分析 1、什么是 CAS 前言：使用锁的代价 Java并发处理中锁非常重要，但是使用锁会带来下面几个问题： 加锁、释放锁会需要操作系统进行上下文切换和调度延时，在上下文切换的时候，cpu之前缓存的指令和数据都将失效，这个过程将增加系统开销。 多个线程同时竞争锁，锁竞争机制本身需要消耗系统资源。没有获取到锁的线程会被
JUC并发编程与源码分析笔记11-Java对象内存布局和对象头
王劭阳的博客
03-05 501
在HotSpot虚拟机里，对象在堆内存中的存储布局可以划分为三个部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。
JUC并发编程原理精讲（源码分析）
不吃紫菜的博客
05-04 659
1. JUC前言知识 JUC即 java.util.concurrent 涉及三个包： java.util.concurrent java.util.concurrent.atomic java.util.concurrent.locks 普通的线程代码： Thread Runnable 没有返回值、效率相比入 Callable 相对较低！ Callable 有返回值！【工作常用】 1....
JUC并发编程与源码分析学习笔记(二)
xizheng2018的博客
01-20 574
悲观锁：认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改synchronized关键字和Lock的实现类都是悲观锁。
JUC并发编程与源码分析笔记08-CAS
王劭阳的博客
12-11 367
再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。一个线程获取到变量的值是A，它打算把变量的值改为B，不过这时候另一个线程优先级更高，提前将A改为了B，然后又将B改为了A，原始线程在进行CAS的时候，依然是成功的，但是原始线程并不知道，变量的值已经发生过变动，这可能就是有问题的。
JUC并发编程02——AQS源码剖析
BASK2311的博客
12-10 575
通过CAS将同步状态位state从0修改为1，如果修改成功，表示获得锁；如果修改失败，则表示锁被其他线程占有，此时需要排队排队的逻辑就是将当前线程封装到Node节点中，然后尾插法插入到CLH同步队列的尾部，然后调用LockSupport.park()阻塞当前线程获得锁的线程释放锁后，将会调用LockSupport.unpark()方法从头部开始唤醒阻塞的线程（先进先出的体现）好了，关于AQS的介绍就到这里吧，后面有问题再补充。
JUC并发编程与源码分析笔记01-本课程前置知识及要求说明
王劭阳的博客
11-26 672
课程使用IDEA来讲解，要求熟练使用IDEA相关操作。
"并发编程中的线程与线程池原理解析与应用
在这个培训中，我们将深入探讨线程的概念、线程的生命周期与状态转换、线程池的原理与参数配置，以及一些常见的并发编程问题和解决方案。 首先，我们来了解一些基本概念。线程是操作系统进行任务调度的最小单位，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值