线程池浅析 ThreadPoolExecutor FutureTask

最新推荐文章于 2024-08-19 11:07:18 发布
最新推荐文章于 2024-08-19 11:07:18 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42189048/article/details/108895559
版权

线程池浅析 ThreadPoolExecutor FutureTask

前言

程序中使用 多线程 的场景，可以使用 线程池 来 创建、管理 线程。使用 线程池 可以提高程序的性能，减少每个任务调用开销，并且允许我们针对具体的场景限制资源，比如 线程数、任务数 等

ThreadPoolExecutor

我们在程序中创建的 线程池 一般使用 ThreadPoolExecutor（包括 Executors 的相关方法创建的也是 ThreadPoolExecutor）

ThreadPoolExecutor 允许我们指定 核心线程数、最大线程数、任务队列、线程空闲时间 等属性

接下来我们对 线程池 的重要属性进行解读

corePoolSize & maximumPoolSize

当我们调用 ThreadPoolExecutor#execute 方法给线程池分配一个任务

  • 如果此时 线程池 中运行的线程数小于 corePoolSize，则即便当前有线程空闲，线程池 也会创建一个新的线程来执行目标任务
  • 如果 线程池 中允许的线程数已经达到 corePoolSize，则目标任务会被添加到 任务队列，如果队列满了才会继续创建新的线程直到线程数达到 maximumPoolSize
  • corePoolSize 和 maximumPoolSize 属性由 ThreadPoolExecutor 的构造方法指定，同时也提供了 setCorePoolSize 和 setMaximumPoolSize 方法设置
  • 同时还提供了 prestartCoreThread 和 prestartAllCoreThreads 方法，允许提前创建对应数量（或者全部）的 core threads（核心线程）

threadFactory

执行任务的线程由我们指定的 ThreadFactory 创建，如果不指定，ThreadPoolExecutor 则默认由 Executors#defaultThreadFactory 方法返回的 DefaultThreadFactory 创建，该工厂创建的线程拥有同样的 线程组、优先级、守护状态 等

keepAliveTime

默认情况下，如果运行的线程数超过 corePoolSize，则超过的这部分线程如果空闲超过 keepAliveTime，便会被销毁，此举利于节省开销、管理资源

如果想同样对 corePoolSize 数量内的线程生效，则可以调用 allowCoreThreadTimeOut(true) 方法进行指定

允许空闲时长 keepAliveTime 同样可以在 构造方法 指定，也可以调用 setKeepAliveTime 方法设置

workQueue

任务队列，前文提到，当允许的线程数达到 corePoolSize 后，后续的任务会被放入 任务队列 中

ThreadPoolExecutor 的任务队列由 BlockingQueue 实现，基于 Queue 拓展了以下功能

  • 当队列满时，允许插入操作 put 阻塞
  • 当队列为空时，允许取出操作 take 阻塞
ThreadPoolExecutor 插入任务调用的 offer 方法，因为允许拒绝
	任务（见后文），取出任务使用的是 take 和 poll（阻塞版）
	关于常用的 BlockingQueue 的解读，可以参考下面几篇文章

【源码】JUC —— BlockingQueue ArrayBlockingQueue 浅析

【源码】JUC —— LinkedBlockingQueue 浅析

使用 Executors 类创建的线程池，默认使用 LinkedBlockingQueue

handler

如果任务队列满了，且运行的线程数已经达到 maximumPoolSize，则之后的任务交由 handler 处理，ThreadPoolExecutor 默认实现了 4 种 RejectedExecutionHandler

CallerRunsPolicy

	public static class CallerRunsPolicy implements RejectedExecutionHandler {

        public CallerRunsPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

目标任务由 当前线程 执行执行，也相当于缓冲了任务的发放

AbortPolicy

	public static class AbortPolicy implements RejectedExecutionHandler {

        public AbortPolicy() { }

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

直接抛出 RejectedExecutionException 异常

DiscardPolicy

	public static class DiscardPolicy implements RejectedExecutionHandler {

        public DiscardPolicy() { }

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

啥也不干，相当于目标任务直接被 丢弃 了

DiscardOldestPolicy

	public static class DiscardOldestPolicy implements RejectedExecutionHandler {

        public DiscardOldestPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

把排在 队首 的元素 poll 出来（相当于丢掉了），然后继续执行当前任务（当然也并 不能 保证执行成功）

构造方法

依次解读了 ThreadPoolExecutor 的几个核心属性后，我们看看 ThreadPoolExecutor 提供的构造方法

	// 不指定 threadFactory 和 handler
	public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

	// 不指定 handler
	public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

	// 不指定 threadFactory 
	public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

	// 全构造
	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;
    }
  • corePoolSize，核心线程数
  • maximumPoolSize，最大线程数
  • keepAliveTime，允许线程空闲的最大时长
  • unit，keepAliveTime 的时间单位
  • workQueue，任务队列
  • threadFactory，如果没有提供，则使用默认的 DefaultThreadFactory
  • handler，如果没有指定，使用默认的 AbortPolicy，即抛出异常

FutureTask

我们看到 ThreadPoolExecutor#execute 方法接受一个 Runnable，同样 ThreadPoolExecutor 也接受 Callable，以获取异步执行的任务结果

ThreadPoolExecutor 的父类 AbstractExecutorService 实现了 ExecutorService 接口，ExecutorService 接口定义了 submit 相关方法，来支持异步任务结果的获取

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

Callable

Callable 类似与 Runnable，它提供了 call 方法，类似于 Runnable#run，但 call 方法如何做到被 Thread类 调用？

Future

Future 用来抽象 异步任务 的结果返回，提供了 get 方法 阻塞式 地获取异步任务的执行结果，同样提供了 取消任务执行、任务状态获取 等相关方法

public interface Future<V> {

    /**
     * 取消执行中的异步操作，但并不保证取消成功，如下场景会失败
     * 1）取消已经完成的操作
     * 2）已被取消过
     * 3）由于其他某些原因无法取消
     *
     * 如果取消的目标任务并未执行，那它必然不会再执行了
     * 但如果目标任务已经在执行了，则它是否中断取决于
     *      参数 mayInterruptIfRunning
     *
     * 执行该方法后调用 isDone 方法返回 true
     * 该方法如果返回 true 则调用 isCancelled 方法也返回 true
     */
    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    /**
     * Done 表示
     * 1）执行完成
     * 2）执行异常
     * 3）被取消
     */
    boolean isDone();

    // 阻塞直到异步任务返回结果
    V get() throws InterruptedException, ExecutionException;

    // 阻塞指定时间
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

RunnableFuture

public interface RunnableFuture<V> extends Runnable, Future<V> {

    void run();
}

RunnableFuture 接口就将 Runnable 和 Future 连接了起来

FutureTask

FutureTask，RunnableFuture 的实现类

  • 它是一个 Runnable，因此可以被 Thread 执行，换句话说，可以作为 异步任务 被 线程池 执行
  • 它是一个 Future，因此支持 异步任务 的执行以及结果的 阻塞式 获取

我们来看看 FutureTask 的构造方法

	// 接受一个 Callable，直接赋值给属性 callable
	public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;
    }

	// 接受一个 Runnable，由 Executors#callable 创建对应的 callable 
	public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;
    }
  • 允许直接指定一个 callable
  • 允许指定一个 runnable 和返回结果 result，委托 Executors#callable 创建对应的 callable，代码如下
	public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

	private static final class RunnableAdapter<T> implements Callable<T> {
        private final Runnable task;
        private final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
        
        // ...
    }

通过 适配器 类 RunnableAdapter，将目标 Runnable 适配成对应的 Callable，适配器设计模式 的经典使用场景

AbstractExecutorService

最后我们看看 ThreadPoolExecutor 的父类 AbstractExecutorService 如何实现 submit 方法，以实现 线程池对 异步任务 的执行和结果的 阻塞式 获取

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

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

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

可以看到，submit 方法在将目标任务转换成 RunnableFuture 后交由 execute 方法执行，同时返回它以支持结果的 阻塞式 获取

	protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

方法 newTaskFor 就是创建对应的 RunnableFuture 并返回

示例

如此，我们对线程池 ThreadPoolExecutor 的属性和对异步任务的支持做了解读，给出示例 demo

public class ThreadPoolTest {

    /**
     * corePoolSize: 2
     * maximumPoolSize: 4
     * keepAliveTime: 1s
     * workQueue: 容量为 4 的 LinkedBlockingQueue
     * threadFactory: 默认的 DefaultThreadFactory
     * handler: 默认的 AbortPolicy，抛异常
     */
    ThreadPoolExecutor threadPoolExecutor
            = new ThreadPoolExecutor(
                    2
                    , 4
                    , 1
                    , TimeUnit.SECONDS
                    , new LinkedBlockingQueue<>(4)
                    // , (r, t) -> System.out.println("reject handle")
    );

    // 执行任务耗时 2s
    Runnable runnable = () -> {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    };

    @Test
    public void test1() throws InterruptedException {

        // 如果调用此方法，在所有任务执行完成 1s 后，所有线程被销毁
        // threadPoolExecutor.allowCoreThreadTimeOut(true);

        /**
         * 执行 10 个任务
         * 第 1，2 个任务创建新的线程执行（耗时 2s）
         * 第 3，4，5，6 个任务放到 workQueue 中
         * 因为队列满了，第 7，8 个任务继续创建线程直到 maximumPoolSize（4）
         * 之后的第 9，10 个任务抛出异常（做了处理）
         */
        for (int i = 0; i < 10; i++) {
            try {
                threadPoolExecutor.execute(runnable);
            } catch (RejectedExecutionException re) {
                System.out.println("任务溢出了");
            }

            System.out.println("-----------------------");
            System.out.println("ActiveCount: " + threadPoolExecutor.getActiveCount());
            System.out.println("PoolSize: " + threadPoolExecutor.getPoolSize());
            System.out.println("QueuedCount: " + threadPoolExecutor.getQueue().size());
            System.out.println("-----------------------");
        }

        /**
         * 2s 后第一轮任务执行完成
         */
        TimeUnit.SECONDS.sleep(2);
        System.out.println("--------------------------");
        System.out.println("ActiveCount: " + threadPoolExecutor.getActiveCount());
        System.out.println("PoolSize: " + threadPoolExecutor.getPoolSize());
        System.out.println("QueuedCount: " + threadPoolExecutor.getQueue().size());
        System.out.println("--------------------------");

        /**
         * 又 2s 后第二轮任务执行完成，所有任务执行完
         */
        TimeUnit.SECONDS.sleep(2);
        System.out.println("--------------------------");
        System.out.println("ActiveCount: " + threadPoolExecutor.getActiveCount());
        System.out.println("PoolSize: " + threadPoolExecutor.getPoolSize());
        System.out.println("QueuedCount: " + threadPoolExecutor.getQueue().size());
        System.out.println("--------------------------");
        /**
         * 线程空闲 1s 后，超过 corePoolSize 的线程被回收
         */
        TimeUnit.SECONDS.sleep(1);
        System.out.println("---------------------------");
        System.out.println("ActiveCount: " + threadPoolExecutor.getActiveCount());
        System.out.println("PoolSize: " + threadPoolExecutor.getPoolSize());
        System.out.println("QueuedCount: " + threadPoolExecutor.getQueue().size());
        System.out.println("---------------------------");
        /**
         * 日志打印如下，结合回顾线程池的创建过程
         * --------------------------------------------
         * ActiveCount: 1
         * PoolSize: 1
         * QueuedCount: 0
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 2
         * PoolSize: 2
         * QueuedCount: 0
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 2
         * PoolSize: 2
         * QueuedCount: 1
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 2
         * PoolSize: 2
         * QueuedCount: 2
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 2
         * PoolSize: 2
         * QueuedCount: 3
        * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 2
         * PoolSize: 2
         * QueuedCount: 4
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 3
         * PoolSize: 3
         * QueuedCount: 4
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 4
         * PoolSize: 4
         * QueuedCount: 4
         * --------------------------------------------
         * 任务溢出了
         * --------------------------------------------
         * ActiveCount: 4
         * PoolSize: 4
         * QueuedCount: 4
         * --------------------------------------------
         * 任务溢出了
         * --------------------------------------------
         * ActiveCount: 4
         * PoolSize: 4
         * QueuedCount: 4
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 3
         * PoolSize: 4
         * QueuedCount: 0
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 0
         * PoolSize: 4
         * QueuedCount: 0
         * --------------------------------------------
         * --------------------------------------------
         * ActiveCount: 0
         * PoolSize: 2
         * QueuedCount: 0
         * --------------------------------------------
         */
    }

    volatile AtomicInteger atomicInteger = new AtomicInteger();

    // 阻塞 1s 后返回
    Callable<Integer> callable = () -> {
        TimeUnit.SECONDS.sleep(1);
        return atomicInteger.incrementAndGet();
    };

    @Test
    public void test2() throws ExecutionException, InterruptedException {
        for (int i = 0; i < 3; i++) {
            System.out.println(threadPoolExecutor.submit(callable).get());
        }

		// 结果
        // 1 2 3
    }
}

总结

本章节介绍了线程池 ThreadPoolExecutor 类，详细解读了 ThreadPoolExecutor 的属性

同时，对 FutureTask 体系的几个接口和类做了简单的解析，以说明 ThreadPoolExecutor 如何支持 异步任务 的执行和对执行结果的 阻塞式 获取

小水牛...
关注
专栏目录
浅析项目实践接触到的java并发线程池应用场景
互联网大厂后端码农，个人IP：无一郎的技术圈，欢迎加入我的知识星球，解锁更多内容
12-31 1020
本文根据最近研读《java并发编程之美》这本书8、9、11章关于线程池的部分与实际项目经历，分析了java并发线程池具体应用场景，并结合个人的思考进行了一定的拓展，记录的过程也是对知识的一种巩固和加强，以便于对并发编程有更深入的理解。
【Java多线程】JUC之线程池(一)与线程池的初识
墩墩分墩
08-21 815
线程池概念 有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统不一定能受得了。 概念：线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。我们将任务添加到任务队列中，线程池得知有任务到来后，会唤醒线程，如若所有线程都在执行任
spring线程池ThreadPoolExecutor配置以及FutureTask的使用
12-14
最代码，http://www.zuidaima.com/share/1724478138158080.htm 的代码及例子
Future，FutureTask，线程池ThreadPoolExecutor
dgh112233的博客
07-01 863
1、Future接口 Future 是配合用Callable实现的线程的，Callable实现的线程可以有返回值，必须等到线程执行完了才会返回值，难道我们要一直等它执行完，岂不是阻塞浪费。因此才用Future来异步获取线程的返回值，不用等待。 public interface Future<V> { /** * Attempts to cancel execution of this task. This attempt will * fail if the
Java并发编程 - JUC线程池（Executor、Callable、FutureTask、ThreadPoolExecutor）
最新发布
qq_33240556的博客
08-19 272
ExecutorCallableFutureTask, 和都是 Java 并发编程中常用的线程池工具，它们各自解决了不同的问题。Executor提供了一个高层的抽象来提交任务到线程池中执行。Callable和FutureTask用于创建可以返回结果的任务，并且可以获取计算的结果。提供了更详细的配置选项，可以更细粒度地控制线程池的行为。在使用这些线程池工具时，通常会结合具体的并发需求来选择合适的工具。这些工具可以有效地帮助管理线程的生命周期，提高并发性能。
【Java并发编程的艺术】Executor框架:ThreadPoolExecutor&ScheduledThreadPoolExecutor&FutureTask
乾坤未定，你我皆是黑马
10-22 605
1.介绍 1.1 Executor框架的两级调度模型 应用程序通过Executor框架控制上层的调度；而下层的调度由操作系统内核控制，下层的调度不受应用程序的控制。 1.2 Executor框架的结构与成员 Executor框架主要由以下3大部分组成： 1.任务。包括被执行任务需要实现的接口：Runnable接口或Callable接口。 2.任务的执行。包括任务执行机制的核心接口Executor，以及继承自Executor的ExecutorService接口。Executor框架有两个关键类实现了Exec
多线程 (2) ThreadPoolExecutor 介绍和 FutureTask使用
laughing
06-24 325
FutureTask是一种可以取消的异步的计算任务。它的计算是通过Callable实现的，并且有三个状态：等待、运行和完成。完成包括所有计算以任意的方式结束，包括正常结束、取消和异常。     V get() 如有必要，等待计算完成，然后检索其结果。 V get(long timeout, TimeUnit unit) 如有必要，最多等待为...
Java并发之ThreadPoolExecutor和FutureTask
岁月静好
10-14 4865
ExecutorService.submit(Runnable task)方法及其重载方法的返回类型为Future，其真实类型为FutureTask。类图如下： future.get()是一个阻塞方法，知道任务完成才返回。再看ThreadPoolExecutor类图： 当ExecutorService.submit(Runnable task)方法及其重载方法执行时（这些方法由
阻塞队列原理和线程池源码浅析
vanchine的博客
12-27 461
阻塞队列 非阻塞队列是一个先进先出的单向队列（Queue），而BlockingQueue阻塞队列实际是非阻塞队列的一个加强，之所以是阻塞队列最主要的是实现take和put，当阻塞队列满时，put会一直阻塞直到拿到数据，或者响应中断退出；当队列空时，take元素，队列也会阻塞直到队列可用。 阻塞的意思就是此条线程会处于等待卡死状态，解锁的条件是队列中有另一条线程存入或取出数据了，就会解锁，就相当于队列是仓库，仓库没有货了就生产，有货就能消费，锁条件是notFull和notEmpty。 Throws
Java线程池
baidu_34324281的博客
10-12 197
参考博文: https://blog.csdn.net/javazejian/article/details/50890554 1. Executor框架浅析 1.1 为什么要使用线程池 在Java中,线程的创建和销毁需要一定的开销，如果我们为每一个任务创建一个新的线程来执行的话，那么这些线程的创建与销毁将消耗大量的计算资源。同时为每一个任务创建一个新线程来执行，这样的方式可能会使处于高负荷状态的...
AsyncTask浅析
chen_410063005的专栏
03-17 376
简单分析了AsyncTask的实现
Java并发编程：ThreadPoolExecutor + Callable + Future（FutureTask） 探知线程的执行状况...
weixin_30839881的博客
08-16 578
如题 (总结要点) 使用ThreadPoolExecutor来创建线程，使用Callable + Future 来执行并探知线程执行情况； V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参...
ThreadPoolExecutor源码阅读笔记(二)FutureTask
笨鸟的专栏
04-08 285
BlockingQueue: 队列他决定了任务的调度方式，我们主要关注BlockingQueue的offer, poll,take三个方法 offer往队列里面添加任务如果队列已经满了话返回false， poll在规定的时间内从队列里面取出任务如果队列是空的就返回null,  take也是从队列里面取出任务如果队列是空的则阻塞(保证线程池核心线程一直存在的时候有妙用)SynchronousQ...
Java ThreadPoolExecutor，Callable，Future，FutureTask 详解
shine的博客
08-05 910
当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。invokeAny(collection of tasks)/invokeAny(collection of tasks, long timeout, TimeUnit unit)：阻塞的方法，不会返回 Future 对象，而是返回集合中某一个Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个 Callable，如果一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。同样，也带有超时功能；
多线程 ThreadPoolExecutor线程池和Futuretask
qq_36833673的博客
06-03 408
在平常的开发工作中，经常需要使用多线程，如数据处理，那么ThreadPoolExecutor线程池和Futuretask应该如何使用呢？以上为ThreadPoolExecutor和Futuretask的基本用法。
JDK8线程池-ThreadPoolExecutor执行结果FutureTask源码分析与优化
fenglllle的博客
10-12 1699
前言     上一章讲述了线程池ThreadPoolExecutor的原理。在线程池的运算过程结束后可以有返回值 1. ExecutorService 示例 public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(6); ...
ThreadPoolExecutor的中的submit和FutureTask || 通过Executors 创建线程池的一些实例（Callable和Runnable的在其中的体现）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
02-22 4020
线程的创建方式，Callable接口和Future接口的配合，Runnable任务、Callable任务提交到线程池，他们之间的区别
ThreadPoolExecutor之Future、FutureTask源码解析
qq_40276626的博客
08-26 907
1、Future的出现原因 我们在Java线程池ThreadPoolExecutor详解中利用execute(Runnable r)方法来执行任务，但是有一个缺点，就是无法执行带有返回值的任务。 所以引入了Future来解决这个问题。 2、Future详解 Future中有5个方法： 1、cancel():取消任务 2、isCancelled():任务是否取消成功 3、isDone()：任务是否完成了 4、get():获取返回值，阻塞 5、get(long count,TimeUnit):按照count个
FutureTask取消线程池ThreadPoolExecutor 的任务执行
05-09 914
java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUni
四种线程池和ThreadPoolExecutor的关系
09-02
四种线程池和ThreadPoolExecutor有着密切的关系。在Java中，通过Executors提供了四种线程池，这四种线程池底层都是由ThreadPoolExecutor实现的。ThreadPoolExecutor是一个灵活的线程池类，可以根据需要进行配置和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值