线程池 — Executor

已于 2022-04-19 18:09:43 修改
阅读量897 收藏 3
点赞数 1
分类专栏： 并发处理 文章标签： 线程池 java
于 2021-12-03 14:39:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37543627/article/details/121672221
版权

目录

一、线程池

1. 两级调度模型

2. Executor执行过程

3. Executor结构组成

4. 线程池参数配置

二、代码示例

1. 定义线程池

2. 自定义线程工厂

3. 调用

4. 其他测试

三、源码解析

1. 类图

2. Executor与ExecutorService源码对比

3. CachedThreadPool详解

4. ScheduledThreadPoolExecutor详解

5. Future源码

6. FutureTask详解

四、参考资料

一、线程池

        线程池目的：通过减少频繁创建和销毁线程来降低性能损耗。每个线程都需要一个内存栈，用于存储局部变量、操作栈等信息，可以通过-Xss参数来调整每个线程栈大小（默认64位OS为1024KB）。

        线程池一般配合队列一起工作。设置队列的大小，当超出该阈值后，就进入拒绝策略来处理，从而保护系统免受大流量而导致崩溃。

        创建多少线程？要根据实际业务情况来压测决定。任务类型IO密集型还是CPU密集型、CPU核数，来设置合理的线程池大小、队列大小、拒绝策略等参数。maximumPoolSize（最大核心线程数）设置过大，导致瞬间线程数很多，同时使用LinkedBlockingQueue有大量任务等待线程执行，则会出现GC慢等问题，造成系统响应慢甚至OOM。

        注意线程池执行中无法捕获堆栈上下文，需要记录相关参数，以方便定位问题。

1. 两级调度模型

        Java线程（java.lang.Thread）被一对一映射为本地操作系统线程。Java线程启动时会创建一个本地操作系统线程；当该Java线程终止时，操作系统线程也会被回收。

        如下图所示是Executor框架的两级调度模型。Executor调度任务给线程池里的线程；操作系统调度CPU执行线程。注意：操作系统调度不受Executor调度的影响。

Executor框架的两级调度模型

2. Executor执行过程

        如下图所示是ThreadPoolExecutor执行示意图。步骤如下，参考上图：

  • 1）当前运行的线程数 < corePoolSize，则创建新线程来执行任务（需要获取全局锁）；
  • 2）当前运行的线程数 >= corePoolSize，则任务加入阻塞BlockingQueue;
  • 3）阻塞队列BlockingQueue已满，则创建新的线程来处理任务（需要获取全局锁）；
  • 4）如果创建新线程将使当前运行的线程 > maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

        注意：尽量避免创建新线程，原因是获取全局锁，但是大部分任务加入阻塞队列中；创建的线程会封装成java.util.concurrent.ThreadPoolExecutor.Worker。 

ThreadPoolExecutor执行示意图

3. Executor结构组成

        如下图所示是Executor的使用。可以看出3大部分组成：

  • 定义任务：实现Runnable（无返回）接口或Callable接口（有返回）；
  • 执行任务：线程执行器（ThreadPoolExecutor、ScheduledThreadPoolExecutor）；
  • 任务结果：接口Future和实现Future接口的FutureTask类。 

4. 线程池参数配置

参数说明
corePoolSize核心线程数：即使线程空闲也不会释放（最小线程数）
maximumPoolSize最大线程数：线程池最多维护的线程数
keepAliveTime线程空闲时间：超出该时间，线程被销毁回收，直至corePoolSize
threadFactory线程工厂：创建线程，设置线程名、是否是后台线程
workQueue

任务队列：

        ArrayBlockingQueue：有界阻塞数组队列

        LinkedBlockingQueue：有界/无界阻塞链表队列

        PriorityBlockingQueue：优先级阻塞队列

        SynchronousQueue：无缓冲阻塞队列

rejectedExecutionHandler缓冲队列满后的拒绝策略，见上图

注意：a. 有界阻塞队列需要合理设置队列大小；

           b. SynchronousQueue：当插入一个任务时，必须要移除另一个任务；移除任务时，则必须插入另一个任务。（没有缓冲）

二、代码示例

1. 定义线程池

类型特点
Executors.newSingleThreadExecutor()

1. 单线程线程池；

2. 线程空闲时间是0L；

3. 阻塞队列是LinkedBlockingQueue。

Executors.newScheduledThreadPool(corePoolSize)

1. 固定数量线程池；

2. 线程空闲时间是0L；

3. 阻塞队列是LinkedBlockingQueue。

Executors.newCachedThreadPool()

1. 可缓存线程池（按任务需要创建线程）；

2. 线程空闲时间是60L；

3. 阻塞队列是SynchronousQueue。

Executors.newScheduledThreadPool(corePoolSize)

1. 固定数量的延时或周期执行线程池；

2. 线程空闲时间是0L；

3. 阻塞队列是DelayedWorkQueue。

Executors.newWorkStealingPool(parallelism)

1. Fork/Join线程池（ForkJoinPool）；

2. 工作窃取work-stealing算法；

3. FIFO的双端队列ForkJoinPool.WorkQueue。

new ThreadPoolExecutor()

自定义线程池

package com.common.instance.test.config.pool;

import com.log.util.LogUtil;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.concurrent.*;

/**
 * @description 线程池
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/2 9:53
 **/
@Component
public class ExecutorHelper {

    // 单线程线程池
    @Bean("mySingleExecutor")
    public ExecutorService singleExecutor() {
        /*
            等价于：
            ExecutorService executorService = new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        */
        return Executors.newSingleThreadExecutor();
    }

    // 固定数量线程池
    @Bean("myFixedExecutor")
    public ExecutorService fixedExecutor() {
        /*
            等价于：
            ExecutorService executorService = new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
        */
        return Executors.newFixedThreadPool(10);
    }

    // 可缓存线程池
    @Bean("myCachedExecutor")
    public ExecutorService cachedExecutor() {
        /*
            等价于：
            ExecutorService executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
        */
        return Executors.newCachedThreadPool();
    }

    // 延迟执行线程池
    @Bean("myScheduledExecutor")
    public ExecutorService scheduledExecutor() {
        /*
            等价于：
            ScheduledExecutorService scheduledExecutorService = new ScheduledExecutorService(
                                      corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                                      new DelayedWorkQueue());
        */
        return Executors.newScheduledThreadPool(10);
    }

    // work-stealing线程池
    @Bean("myWorkStealingExecutor")
    public ExecutorService workStealingExecutor() {
        /*
            等价于：
            ExecutorService executorService = new ForkJoinPool(parallelism,
                                      ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                                      null, true);
            默认并行数：Runtime.getRuntime().availableProcessors():物理机核数
        */
        return Executors.newWorkStealingPool(10);
    }

    // 自定义线程池
    @Bean("myPoolExecutor")
    public ExecutorService myPoolExecutor() {
        // 定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                // 核心线程数
                10,
                // 最大线程数
                40,
                // 线程空闲时间
                60,
                // 空闲时间单位
                TimeUnit.SECONDS,
                // 队列大小
                new LinkedBlockingQueue<Runnable>(200),
                // 线程工厂创建线程
                new MyThreadFactory("myPoolExecutor-"),
                // 线程决绝策略
                new ThreadPoolExecutor.CallerRunsPolicy());

        // JVM关闭时，释放线程资源
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                // 关闭线程池，不接受新任务
                executor.shutdown();
                // 等待多久剩余的线程终止操作
                executor.awaitTermination(30, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                LogUtil.error("ExecutorHelper.myPoolExecutor()", "myPoolExecutor awaitTermination failed ", e);
            }
        }));
        return executor;
    }

}

2. 自定义线程工厂

package com.common.instance.test.config.pool;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @description 定义线程工厂 - 参考DefaultThreadFactory
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/2 16:45
 **/
public class MyThreadFactory implements ThreadFactory {

    // 池大小
    private final AtomicInteger poolNumber = new AtomicInteger(1);
    // 线程组
    private final ThreadGroup threadGroup;
    // 线程编号
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    // 线程前缀
    public  final String namePrefix;

    public MyThreadFactory(String name){
        SecurityManager s = System.getSecurityManager();
        threadGroup = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        if (null==name || "".equals(name.trim())){
            name = "pool";
        }
        namePrefix = name +"-"+
                poolNumber.getAndIncrement() +
                "-thread-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(threadGroup, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }

}

3. 调用

package com.common.instance.test.controller;

import com.common.instance.test.core.Response;
import com.common.instance.test.entity.WcPendantTab;
import com.common.instance.test.service.WcPendantTabService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

/**
 * Tab菜单(WcPendantTab)表控制层
 *
 * @author tcm
 * @since 2021-01-14 15:02:08
 */
@Slf4j
@RestController
@RequestMapping("/tab")
@Api(tags = "活动tab测试")
public class WcPendantTabController {

    @Resource
    private WcPendantTabService wcPendantTabService;

    @Resource(name = "myPoolExecutor")
    private ExecutorService executor;

    @PostMapping("/testPoolExecutor")
    @ApiOperation("测试线程池")
    public Response<List<WcPendantTab>> testPoolExecutor(WcPendantTab tab){
        Response<List<WcPendantTab>> response = new Response<>();
        try {
            // 任务提交到线程池
            Future<Object> future = executor.submit(() -> wcPendantTabService.queryAll(tab));
            // 获取任务执行结果
            List<WcPendantTab> result = (List<WcPendantTab>) future.get();

            response.setData(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Response.error();
        }
        return response;
    }

}

4. 其他测试

package com.cmmon.instance;

import org.junit.jupiter.api.Test;

import java.util.Objects;
import java.util.concurrent.*;

/**
 * @description 线程池测试
 * @author TCM
 * @version 1.0
 * @date 2022/4/17 17:32
 **/
public class ExecutorTest {

    ThreadPoolExecutor cachedThreadPool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
    @Test
    public void cachedThreadPoolTest() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread() + ", cachedThreadPool.getPoolSize(): " + cachedThreadPool.getPoolSize());
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        Thread.sleep(6000);
        System.out.println("cachedThreadPool工作队列类型: " + cachedThreadPool.getQueue().getClass());
        System.out.println("6秒后的池线程数量: " + cachedThreadPool.getPoolSize());
        Thread.sleep(62000);
        System.out.println("62秒后的池线程数量: " + cachedThreadPool.getPoolSize());
    }

    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);
    @Test
    public void scheduledThreadPoolTest() throws InterruptedException {
        // 延迟任务执行
        scheduledThreadPool.schedule(() -> {
            System.out.println("延时执行任务");
        }, 10, TimeUnit.SECONDS);

        // 延时后固定周期执行
        // scheduleAtFixedRate(): 延时后以固定周期执行
        // scheduleWithFixedDelay(): 延时后以固定的延迟来执行（前次任务执行完毕后再延时period）
        scheduledThreadPool.scheduleAtFixedRate(() -> {
            System.out.println("固定周期执行任务");
        }, 2, 1, TimeUnit.SECONDS);

        Thread.sleep(40000);
        System.out.println("main thread end");
    }

    final ConcurrentMap<String, Future<String>> concurrentMap = new ConcurrentHashMap<>();
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
    // 测试FutureTask
    @Test
    public void futureTaskTest() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            String taskName = executionTask("taskName" + i);
            System.out.println(taskName);
        }
    }

    private String executionTask(final String taskName) {
        while (true) {
            Future<String> future = concurrentMap.get(taskName);
            if (Objects.isNull(future)) {
                // 定义任务
                Callable<String> callable = new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        return taskName;
                    }
                };

                // 定义一个FutureTask任务
                FutureTask<String> futureTask = new FutureTask<>(callable);
                future = concurrentMap.putIfAbsent(taskName, futureTask);
                if (Objects.isNull(future)) {
                    future = futureTask;
                    // FutureTask直接执行
                    futureTask.run();
                    // 提交给线程池执行
//                    fixedThreadPool.submit(futureTask);
                }
            }

            try {
                return future.get();
            } catch (Exception e) {
                e.printStackTrace();
                concurrentMap.remove(taskName, future);
            }
        }
    }


}

三、源码解析

1. 类图

JDK中ExecutorService有三种实现：

ThreadPoolExecutor：标准线程池

ScheduledThreadPoolExecutor：延迟任务线程池

ForkJoinPool：work-steeling模式线程池。池中的每个线程都创建一个队列，从而使用work-steeling算法（任务窃取）使得任务处理完成的线程从其他忙的线程队列中窃取任务。

2. Executor与ExecutorService源码对比

package java.util.concurrent;

/**
 * 1.该接口提交任务，使得提交任务与任务处理隔离，不显示创建线程；
 * 2.接受一个Runnable接口对象，并没有返回结果
 */
public interface Executor {

    /**
     * 提交任务，使得线程池中的线程处理任务逻辑
     * 注意：该方法并没有返回任务的处理结果
     * @param command Runnable任务
     * @throws RejectedExecutionException 线程池拒绝异常
     * @throws NullPointerException 空指针异常
     */

    void execute(Runnable command);
}
package java.util.concurrent;

import java.util.List;
import java.util.Collection;

/**
 * 1. 提供管理终止的方法，这些方法可跟踪异步线程执行任务的进度
 * 2. 关闭线程池有两种方法：shutdown()、shutdownNow()
 */
public interface ExecutorService extends Executor {

    /**
     * 关闭线程池
     * 1. 拒绝新的任务提交
     * 2. 正在执行的任务完成后关闭
     */
    void shutdown();

    /**
     * 立刻关闭线程池
     * 1. 拒绝新的任务提交
     * 2. 终止等待执行的任务，返回任务
     * 3. 终止正在执行的任务，返回任务
     */
    List<Runnable> shutdownNow();

    // 判定线程池是否关闭
    boolean isShutdown();

    // shutdown()后所有任务是否终止
    boolean isTerminated();

    // shutdown()后所有任务在timeout后终止
    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;

}
ExecutorExecutorService

1.execute()提交任务；

2.接受Runnable接口对象；

3.无返回任务处理结果

1.submit()提交任务；

2.接受Runnable、Callable接口对象；

3.返回任务处理结果；

4.继承Executor接口；

5.有控制线程池的方法，如shutdown()

3. CachedThreadPool详解

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

        如上代码所示，CachedThreadPool是按需创建新线程的线程池，即：corePoolSize=0。keepAliveTime=60L，空闲线程超过60秒后将会被终止。阻塞队列SynchronousQueue，它是一个没有容量的阻塞队列，即：每个插入操作必须等待另一个线程的对应移除操作，反之亦然。
        没有容量的SynchronousQueue作为线程池的工作队列，又是无界的。这意味着，如果主线程提交任务的速度高于线程池线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。
 

CachedThreadPool运行execute()示意图

        如上图所示，对步骤进行说明如下：

  • step1：执行offer()时，如果池中有空闲线程正在执行poll()，那么主线程执行offer操作与空闲线程执行poll操作配对成功，主线程把任务交给空闲线程执行；否则执行step2。
  • step2：池为空或当前没有空闲线程时，此时会创建一个新线程执行任务；
  • step3：step2创建新线程完成任务后，主线程60秒钟内提交了一个新任务，那么执行step1；否则，将终止空闲线程。
SynchronousQueue任务传递示意图

4. ScheduledThreadPoolExecutor详解

        ScheduledThreadPoolExecutor继承自ThreadPoolExecutor，用来延迟或定期执行任务。它比Timer更强大。Timer对应的是单个后台线程，ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
            new DelayedWorkQueue());
}

        以上代码所示， keepAliveTime=0L，空闲线程会立即被终止。使用DelayedWorkQueue阻塞队列存储任务java.util.concurrent.ScheduledThreadPoolExecutor.ScheduledFutureTask，具有延时和周期执行任务。

        ScheduledFutureTask类主要有三个变量，如下。注意time相同时，按sequenceNumber小的优先出队。

  • sequenceNumber：添加到阻塞队列的序列号
  • time：任务执行的绝对时间
  • period：执行任务的间隔周期

        如下步骤是ScheduledFutureTask的任务执行步骤：

  • 1）线程获取可以出队的任务（ScheduledFutureTask的time > 当前时间，说明当前任务可以出队）；
  • 2）线程执行出队任务；
  • 3）线程修改出队任务的time变量（下次被执行的时间）；
  • 4）完成任务后，放回队列。 

5. Future源码

package java.util.concurrent;

/**
 * 返回异步计算的结果
 * 检查计算是否完成；等待计算完成；结算完成获取结果
 */
public interface Future<V> {

    // 取消任务的执行
    boolean cancel(boolean mayInterruptIfRunning);

    // 任务完成前，将其取消，返回true
    boolean isCancelled();

    // 任务正常完成，返回true
    boolean isDone();

    // 等待任务执行完成，获取执行结果
    V get() throws InterruptedException, ExecutionException;
    
    // 等待多久后，获取执行结果（正常完成），否则抛出异常
    V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    
}

6. FutureTask详解

        FutureTask实现Future接口，还实现了Runnable接口。因此，FutureTask任务给Executor执行，也可以线程直接执行（FutureTask.run()）。

FutureTask的状态迁移示意图

        

        上图所示是FutureTask的状态变化示意图，有下面三种状态：

  • 未启动：创建任务，但是调用run()之前；
  • 已启动：调用run()方法；
  • 已完成：任务正常结束、被取消cancel()、抛出异常。
个状态调用get()/cancel()的示意图

        上图所示，注意：任务未启动时，调用cancel()导致此任务永远不会被执行；任务已完成时，调用cancel()方法将返回false。

四、参考资料

Springboot学习笔记（一）-线程池的简化及使用 - 舒山 - 博客园

ThreadPoolExecutor使用详解 - WakamiyaShinobu - 博客园

深入分析java线程池的实现原理 - 简书

多线程——Executor、ExecutorService、Executors三者的区别 - 九零大叔芭蕉 - 博客园

爱我所爱0505
关注
专栏目录
聊聊 ThreadPoolExecutor 线程池及其源码
Huangjiazhen711的博客
10-08 425
在我们的实际开发中，通常使用线程池创建线程资源。而线程池本质上是一种池化技术，利用资源复用的思想，复用线程资源。
Java线程池Executor详解
Trouvailless的博客
08-08 1357
线程池的大小推荐为CPU数量 + 1，CPU数量可以根据Runtime.availableProcessors方法获取CPU数量 * CPU利用率 * (1 + 线程等待时间/线程CPU时间)将任务分为CPU密集型和IO密集型，然后分别使用不同的线程池去处理，从而使每个线程池可以根据各自的工作负载来调整推荐使用有界队列，有界队列有助于避免资源耗尽的情况发生。...
并发编程之线程和线程池
xueguchen的博客
05-27 282
1. 线程 2. 协程 3. 线程池 3.1 简介 3.2 应用场景 3.3 优点 3.4 Executor框架 3.5 线程池重点属性 3.6 线程池的5种状态 3.7 线程池创建参数 3.8 线程池监控相关API 3.9 线程池创建方式 4. 线程池工作流程图
Java零基础-线程池（`ExecutorService`）的使用
最新发布
喵手的博客
08-31 655
在上一期中，我们深入探讨了Java多线程编程的基本概念、实现方法以及线程同步的相关技术，帮助你理解了如何通过多线程来提升程序的性能和响应能力。然而，在实际开发中，频繁创建和销毁线程会带来额外的资源开销，并可能导致系统性能下降。为了解决这一问题，本期我们将聚焦于Java中的线程池机制，介绍的使用方法，帮助你有效管理线程，优化多线程编程的性能。本文将详细介绍Java线程池的概念、接口及其实现类的使用方法，以及线程池的创建与配置。
线程池Executor
zjpp2580369的博客
01-17 489
1.为何需要线程池 在java中，使用线程来执行异步任务时，线程的创建和销毁需要一定的开销，如果我们为每一个任务创建一个新的线程来执行的话，那么这些线程的创建与销毁将消耗大量的计算资源。同时为每一个任务创建一个新线程来执行，这样的方式可能会使处于高负荷状态的应用最终崩溃。所以线程池的出现为解决这个问题带来曙光。我们将在线程池中创建若干条线程，当有任务需要执行时就从该线程池中获取一条线程来执行任务...
Executor线程池实例
java
04-06 145
Executor 是 java5 下的一个多任务并发执行框架(Doug Lea),可以建立一个类似数据库连接池的线程池来执行任务。这个框架主要由三个接口和其相应的具体类组成。Executor、 ExecutorService 和 ScheduledExecutorService 。   1 、 Executor 接口：是用来执行 Runnable 任务的；它只定义一个方法- execute(Run...
Java并发编程(08)：Executor线程池框架
【积累】，是一个长期持续的过程。
08-24 340
Executor系统中，将线程任务提交和任务执行进行了解耦的设计，Executor有各种功能强大的实现类，提供便捷方式来提交任务并且获取任务执行结果，封装了任务执行的过程，不再需要Thread().start()方式，显式创建线程并关联执行任务。...
springmvc配置线程池Executor做多线程并发操作的代码实例
08-26
SpringMVC配置线程池Executor做多线程并发操作的代码实例 在本文中，我们将探讨如何使用SpringMVC框架来配置线程池Executor，以实现多线程并发操作。线程池Executor是Spring框架提供的一种线程池实现，它允许我们在...
Java并发之线程池Executor框架的深入理解
08-26
Java并发之线程池Executor框架的深入理解 Java中的线程池Executor框架是Java并发编程中的一种常见机制，用于管理和执行异步任务。通过使用线程池，可以大大减少线程的创建和销毁开销，从而提高系统的性能和稳定性。...
Android多线程之线程池Executor详解
白哥哥的博客
03-12 2615
前言：前面说过，Android系统延续了Java的单线程设计模型，因此在开发过程中经常会去开辟新的线程，去处理与UI操作无关的任务。线程是操作系统调度的最小单元，同时线程又是一种受限的系统资源，不能无限制的产生，它的创建与销毁都会产生较多的系统开销。因此，为了方便线程的管理，Android提供了线程的管理机制-Executor线程池。 这里简单复习一下，Android在UI线程进行耗时任务出现A...
多线程基础（九）Executors线程池
m0_47743175的博客
06-18 1858
Executors线程池
Executors线程池的使用
喝醉的咕咕鸟
11-12 429
Java通过Executors提供四种线程池，分别为： newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。 new...
线程池（Executor框架）
zxadcsdn的博客
11-07 856
任务是一组逻辑工作单元，而线程则是使任务异步执行的机制。 当把所有任务都放在单个线程中串行执行时，会产生糟糕的响应性； “为每个任务分配一个线程”资源管理的复杂性会升高，不足如下： 线程生命周期的开销非常高。（创建和销毁） 资源消耗 活跃资源消耗资源，尤其内存。当可运行线程大于可用处理器时，有些线程将闲置，从而闲置线程占用许多内存，给垃圾回收器带来压力，而且在竞争CPU会有其他性能消耗。 稳定性...
Java 异步编编程——Java内置线程池（Executor 线程池）
longool的博客
05-31 1227
默认情况下，只有当线程池中的线程数大于 corePoolSize 时，keepAliveTime 才会起作用，直到线程池中的线程数不大于 corePoolSize，即当线程池中的线程数大于 corePoolSize 时，如果一个线程空闲的时间达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。线程管理部分是消费者，它们被统一维护在线程池内，根据任务请求进行线程的分配，当线程执行完任务后则会继续获取新的任务去执行，最终当线程获取不到任务的时候，线程就会被回收。
Executor线程池解析
felix_wangq的博客
11-17 860
1 概述Executor 框架是一个根据一组执行策略调用，调度，执行和控制的异步任务的框架。其位于java.util.concurrent包中。它提供了一种将”任务提交”与”任务运行”分离开来的机制。 线程池有两个作用：1、避免thread不断创建销毁的开销； 2、通过使用线程池可以限制这些任务所消耗的资源,比如最大线程数，最大的消息缓冲池等,已达到最佳的运行效果。其包含了一系列的接口，和实现类，
多线程--Executor线程池框架
aimangqi8019的博客
06-15 94
Executor的介绍 在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关...
线程池-ExecutorService
ljz2016的博客
02-21 1090
关闭一个ExecutorService，有两个方法可以使用–shutdown和shutdownNow。 shutdown在关闭线程池前，会等待所有线程执行完；shutdownNow会立刻关闭线程池，并停止所有线程。 ...
Java并发编程：第四章 线程池（Executor框架）
玉汝于成
03-20 1571
Executors 是 Java 并发包 java.util.concurrent 中的一个工具类，它提供了一组用于创建线程池的方法。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的 ThreadFactory 创建一个新线程。Executors 工具类的主要目的是简化线程池的创建和管理。
Executor 线程池
风归去.
10-18 209
前几天在工作中，遇到了线程池的问题，突然发现有很多不会的东西，然后就查资料，文档进行学习。 总结一下内容，方便自己以后进行查阅复习。 Executor 线程池_学习笔记 1.线程 1.1 线程 线程是调度 CPU 资源的最小单位，线程模型分为 KLT 模型与 ULT 模型，JVM 使用的是 KLT 模型，Java 线程与 OS 线程保持 1:1 的映射关系，也就是说一个 Java 线程也会在操作系统里有一个对应的线程。Java 线程由多种生命状态 NEW：新建 RUNNABLE：运行 BLOCKED：
代码优化 def process_data(data): # 处理数据逻辑 print("Processing data:", data) def push_data(data_queue:queue.Queue): while True: data_queue.put(str("123")) time.sleep(0.5) # Press the green button in the gutter to run the script. if __name__ == '__main__': print_hi('PyCharm') data_queue = queue.Queue() data_thread = threading.Thread(target=process_data, args=(data_queue,)) data_thread.start() # 创建线程池 executor = ThreadPoolExecutor(max_workers=5) # 从队列中获取数据并处理 while True: data = data_queue.get() if data: print('data = {}'.format(data)) # 提交任务到线程池 executor.submit(process_data, data)
06-01
因此，我们可以将`process_data`函数的内容移动到`push_data`函数中，然后将`process_data`函数从`ThreadPoolExecutor`中删除，直接在`executor.submit`中调用`push_data`函数即可。 其次，`push_data`函数中的无限...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值