ExecutorService线程池使用、Future、Callable 接口

已于 2024-08-21 16:52:03 修改
阅读量1k 收藏 12
点赞数 29
分类专栏： JAVA 文章标签： java
于 2024-08-21 16:47:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61160520/article/details/141392706
版权

在这里插入图片描述

一、ExecutorService

ExecutorService 接口提供了一种灵活的方式来管理和执行线程。它不仅可以帮助管理线程池，还可以控制线程的生命周期，从而提高应用程序的性能和可维护性。

ExecutorService 的作用

  • 线程池管理：ExecutorService 提供了一个线程池，可以在其中执行多个任务。这些任务可以是 Runnable 或 Callable 对象。
  • 异步任务执行：ExecutorService 可以异步地执行任务，并返回 Future 对象，用于获取任务的结果或取消任务。
  • 任务调度：除了执行任务外，某些实现还支持定时执行任务。
  • 线程资源管理：自动管理线程的创建、销毁和重用，减少了线程创建和销毁的开销。

ExecutorService 的常见方法

  • submit(Runnable task)：
    提交一个 Runnable 任务用于执行，并返回一个 Future 对象。
  • submit(Callable task)：
    提交一个 Callable 任务用于执行，并返回一个 Future 对象。
  • invokeAll(Collection<? extends Callable> tasks)：
    提交一组 Callable 任务，等待所有任务完成，并返回一个 List<Future>。
  • invokeAny(Collection<? extends Callable> tasks)：
    提交一组 Callable 任务，并返回第一个完成的任务的结果。如果所有任务都失败，则抛出异常。
  • shutdown()：
    关闭 ExecutorService，不再接受新任务，但允许已提交的任务继续执行。
  • shutdownNow()：
    尝试停止所有正在执行的任务，并返回未执行的任务列表。
  • isShutdown() 和 isTerminated()：
    分别用于检查服务是否已经关闭或所有任务是否已经终止。

创建使用 ExecutorService

Java 提供了几种创建线程池的方法：

  • Executors.newFixedThreadPool(int nThreads)：
    创建一个固定大小的线程池。
  • Executors.newCachedThreadPool()：
    创建一个可以根据需要创建新线程的线程池，但会在一段时间内缓存线程以供重用。
  • Executors.newScheduledThreadPool(int corePoolSize)：
    创建一个支持定时及周期性任务执行的线程池。
  • Executors.newSingleThreadExecutor()：
    创建一个只包含一个线程的线程池。
    示例：创建一个Runnable
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RunnableExample {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交 Runnable 任务
        executor.submit(() -> {
            // 任务执行
            System.out.println("Executing Runnable task...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Over...");
        });

        // 关闭 ExecutorService
        executor.shutdown();
    }
}

import java.util.concurrent.*;

public class ExecutorServiceRunnableExample {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 提交多个 Runnable 任务
        for (int i = 0; i < 5; i++) {
            int taskId = i;
            executor.submit(new Task(taskId));
        }

        // 关闭 ExecutorService
        executor.shutdown();

        // 等待所有任务完成
        while (!executor.isTerminated()) {
            Thread.sleep(100); // 短暂休眠，避免忙循环
        }

        System.out.println("所有任务已完成！");
    }

    static class Task implements Runnable {
        private final int taskId;

        public Task(int taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            System.out.println("任务 " + taskId + " 正在执行...");
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("任务 " + taskId + " 被中断！");
            }
            System.out.println("任务 " + taskId + " 完成！");
        }
    }
}

输出：
任务 2 正在执行...
任务 3 正在执行...
任务 0 正在执行...
任务 1 正在执行...
任务 2 完成！
任务 0 完成！
任务 3 完成！
任务 4 正在执行...
任务 1 完成！
任务 4 完成！
所有任务已完成！

二、Future

Future 的主要用途

  • 异步结果获取：Future 允许你在计算完成之后获取结果，而不是阻塞主线程等待结果。
  • 任务取消：通过 Future 对象，你可以在任何时候取消一个正在执行的任务。
  • 任务状态检查：Future 提供了一些方法来检查任务的状态，比如任务是否已经完成。

Future 的常用方法

结果获取

  • get()：阻塞等待直到计算完成，并返回计算的结果。如果没有设置超时，get() 方法会一直阻塞直到结果可用。
  • get(long timeout, TimeUnit unit)：阻塞等待直到计算完成或超时，返回计算的结果。如果在指定时间内计算没有完成，则抛出 TimeoutException。

任务取消

  • cancel(boolean mayInterruptIfRunning)：尝试取消计算。如果计算正在进行中，mayInterruptIfRunning 参数指定了是否中断正在执行的线程。

状态检查

  • isCancelled()：返回计算是否被取消。
  • isDone()：返回计算是否完成，无论成功还是失败。、

三、Callable

Callable 接口定义了一个 call() 方法，该方法可以抛出异常。Callable 接口定义了一个 call 方法，该方法可以抛出异常。
源代码
Callable 接口和Runnable相似，但相比于 Runnable 接口提供了几个重要的增强功能，使其更适合于执行需要返回结果的任务和处理可能抛出的异常。

1. 异常处理

  • Runnable：Runnable 的 run 方法不能抛出受检查的异常（checked exception），只能抛出运行时异常（runtime exception）或错误（error）。
  • Callable：Callable 的 call 方法可以抛出受检查的异常。这意味着你可以更好地控制异常的处理逻辑，并且可以在调用者处捕获和处理这些异常。

2. 异步结果获取

  • Runnable：当你使用 Runnable 执行任务时，你无法直接获取任务的结果，因为 run 方法没有返回值。你需要另外的机制来同步或异步地获取结果。
  • Callable：通过 ExecutorService 提交 Callable 任务后，你会得到一个 Future 对象。Future 允许你以同步或异步的方式获取结果。你可以使用 get() 方法阻塞等待结果，也可以使用 isDone()、cancel() 等方法来检查任务状态或取消任务。

示例：在ExecutorService线程池中创建提交Callable线程任务并获取线程返回的结果

import java.util.concurrent.*;

public class Example {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 创建并提交 Callable 任务
        Future<Integer> future = executor.submit(new SumTask(1, 100));

        // 获取结果
        Integer result = future.get(); // 阻塞直到任务完成
        System.out.println("The sum is: " + result);

        // 关闭 ExecutorService
        executor.shutdown();
    }

    static class SumTask implements Callable<Integer> {
        private int start;
        private int end;

        public SumTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public Integer call() {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }
    }
}

使用ExecutorService 运行Runnable和Callable线程：

import java.util.concurrent.*;

public class ThreadPoolTest {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        //设置线程池的属性
//        System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setMaximumPoolSize(50); //设置线程池中线程数的上限

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

        try {
            Future future = service.submit(new NumberThread2());//适合使用于Callable
            System.out.println("总和为：" + future.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
        //3.关闭连接池
        service.shutdown();
    }

}

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread2 implements Callable {
    @Override
    public Object call() throws Exception {
        int evenSum = 0;//记录偶数的和
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                evenSum += i;
            }
        }
        return evenSum;
    }

}

总结

Callable 本身并不能直接运行，它需要通过某种方式提交给执行器（如 ExecutorService）或包装成 FutureTask 然后在一个线程中执行。这是因为 Callable 接口本身只是一个定义了 call 方法的接口，它并不包含任何执行机制。

我来变强了
关注
专栏目录
Java中ExecutorService线程池的使用(Runnable和Callable多线程实现)
BADAO_LIUMANG_QIZHI的博客
08-09 7645
线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。不利于扩展，比如如定时执行、定期执行、线程中断，所以很有必要了解下ExecutorService的使用。ExecutorService是Java提供的线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。...
Executors 封装的四种线程池 各自有何特点,如何使用 超详细 代码动图演示
Andrew_Chenwq的博客
09-05 901
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。
Java 中的 ExecutorService 与线程池管理
最新发布
qq_40697623的博客
09-11 961
是 Java 并发包 () 中的一个接口，主要用于管理线程池。与手动创建线程的方式不同，它将任务提交给线程池，并管理这些线程的生命周期。通过，我们可以轻松控制线程的创建、执行、关闭等操作。：提交任务给线程池执行，返回一个Future，代表任务的执行结果。shutdown()：有序关闭线程池，不再接受新的任务，但会完成已提交的任务。：立即关闭线程池，并尝试中断正在执行的任务。：执行多个任务，等待所有任务完成并返回结果。：执行多个任务，只要其中一个任务完成，就返回该任务的结果。通过。
ExecutorService、Callable、Future实现有返回结果的多线程原理解析
java1527的博客
09-25 511
以上就是执行线程任务run方法后，如何将线程任务结果返回给主线程，其实，还少一个地方补充，就是如何将FutureTask任务丢给线程执行，我们这里用到了线程池， 但是execute(ftask)底层同样是使用一个了线程通过执行start方法开启一个线程，这个新运行的线程最终会执行FutureTask的run方法。因此，我自定义了一个实现Callable接口的类，该类的重写了call方法，我们在执行多线程时希望返回什么样的结果，就可以在该重写的call方法定义。
ExecutorService(任务调度器)详解
深入一点
04-06 870
前言:这是一次艰苦的旅行... 一.ExecutorService: 它也是一个接口，它扩展自Executor接口，Executor接口更像一个抽象的命令模式，仅有一个方法:execute(runnable);Executor接口简单，但是很重要，重要在这种设计的模式上。。   ExecutorService在Executor的基础上增加了“service”特性的方法： shutd...
java并发中ExecutorService的使用
热门推荐
程序那些事
03-10 1万+
文章目录创建ExecutorService为ExecutorService分配Tasks关闭ExecutorServiceFutureScheduledExecutorServiceExecutorService和 Fork/Join java并发中ExecutorService的使用 ExecutorService是java中的一个异步执行的框架，通过使用ExecutorService可以方便的...
ExecutorService的十个使用技巧
chengji3972的博客
12-21 241
ExecutorService的十个使用技巧 ExecutorService这个接口从Java 5开始就已经存在了。这得追溯到2004年了。这里小小地提醒一下，官方已经不再支持Java 5, Java 6了，Java 7在半年后也将停止支持。我之所以会提起ExecutorService这么...
详解JDK中ExecutorService与Callable和Future对线程的支持
08-29
Java并发编程中的ExecutorService、Callable和Future ...在实际应用中，我们可以使用ExecutorService、Callable和Future来实现各种并发编程任务，如统计某个盘子的大小、统计多个盘子的总大小、实现高效的数据处理等。
java利用线程池（ExecutorService）配合Callable和Future实现执行方法超时的阻断
dupeng41255的专栏
06-09 2939
今天在项目开发中需要用到对执行方法加上时间控制，如果方法执行过长则跳出执行，废话不说，直接上代码，用的是线程池配合Callable和Future方式对执行方法的超时阻断。希望各位牛人指正  //启用线程池 final ExecutorService exec = Executors.newFixedThreadPool(1); Callable>
ExecutorService线程池
07-30
ExecutorService线程池是Java并发编程中的核心组件，它位于`java.util.concurrent`包下，是`java.util.concurrent.Executor`接口的一个实现。ExecutorService提供了一种管理线程的方式，允许我们创建、管理和控制...
Java并发编程系列13:通过Callable接口+Future接口实现多线程
fen_fen的专栏
01-09 774
通过Callable接口+Future接口实现多线程 优点:可以获取返回值 Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类是课被其他线程执行的任务。 Callable和Runnable有几点不同： 1）Callable规定的方法是call(),而Runnable规定的方法是runn() 2)call方法可抛出异常，而runn方法是不能抛出异常的 3)Callable的任务执行后可返回值，运行Callable任务可难道一个Future对象，而Runn
ExecutorService 四种使用方式
wjavadog的博客
08-10 1561
Java 通过 Executors 提供四种线程池, 例如： newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。...
ExecutorService 的理解与使用
互联网那些事
11-20 1109
接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。壹個 ExecutorService 实例因此特别像壹個线程池。事实上，在 java.util.concurrent 包中的 ExecutorService 的实现就是壹個线程池的实现。 ExecutorService 样例 这里有壹個简单的使用Java 实现...
Java并发编程 - Executor，Executors，ExecutorService, CompletionServie,Future,Callable
Josh_Persistence
10-18 223
一、Exectuor框架简介        Java从1.5版本开始，为简化多线程并发编程，引入全新的并发编程包:java.util.concurrent及其并发编程框架（Executor框架）。 Executor框架是指java 5中引入的一系列并发库中与executor相关的一些功能类，其中包括线程池，Executor，Executors，ExecutorService，Completi...
ExecutorService
Robin Hu的专栏
11-24 8118
ExecutorService java.util.concurrent 接口 ExecutorService 所有超级接口：     Executor 所有已知子接口：     ScheduledExecutorService 所有已知实现类：     AbstractExecutorService, ScheduledThreadPoolExecutor, ThreadPool
线程池
weixin_45966880的博客
02-15 162
线程池 1. 线程池的使用 线程池接口是java.util.concurrent.ExecutorService。 要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在java.util.concurrent.Executors线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。 Executors类中有个创建线程池的方法如下： public static ExecutorService newFixedThreadPool(int nThr
ExecutorService 的使用
屋顶小黑猫
02-06 1090
ExecutorService 是大神Doug Lea在并发包里为我们提供的一个便携式的线程池的操作接口， 一般使用Executors 来创建各种类型的线程池，大家比较脸熟的是下面四种 newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。 newCachedT...
基于 ExecutorService线程池工具类
09-03
你好！对于基于 ExecutorService 线程池工具类的问题，我可以给你一些基本的解释和用法示例。 ExecutorService 是 Java 提供的一个线程池工具类，它可以帮助我们管理和执行线程任务。它的主要作用是重用线程，减少线程创建和销毁的开销，提高程序的性能。 首先，我们需要创建一个 ExecutorService 实例。可以使用 Executors 类的静态方法来创建不同类型的线程池，比如： ```java ExecutorService executorService = Executors.newFixedThreadPool(5); ``` 上面的代码创建了一个固定大小为 5 的线程池。你也可以根据需求选择其他类型的线程池，比如 CachedThreadPool、SingleThreadExecutor 等。 接下来，我们可以向线程池提交任务。可以通过调用 `submit()` 方法来提交一个 Callable 或 Runnable 对象，例如： ```java executorService.submit(new Callable<String>() { @Override public String call() throws Exception { // 在这里编写需要执行的任务逻辑 return "任务执行结果"; } }); ``` 或者使用 Lambda 表达式简化代码： ```java executorService.submit(() -> { // 在这里编写需要执行的任务逻辑 return "任务执行结果"; }); ``` 提交任务后，线程池会自动分配一个可用的线程去执行任务，并返回一个 Future 对象，可以用来获取任务的执行结果。 最后，当我们不再需要线程池时，可以调用 `shutdown()` 方法来关闭线程池： ```java executorService.shutdown(); ``` 这会等待已提交的任务执行完毕，并停止接受新的任务。 以上就是基于 ExecutorService 线程池工具类的基本用法。希望对你有所帮助！如果你还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值