【学习】线程池：获取任务执行结果get与取消任务cancel方法

已于 2022-02-13 22:31:36 修改
阅读量2.3k 收藏 8
点赞数 2
分类专栏： 线程池 文章标签： java 开发语言 后端
于 2022-02-11 22:44:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010328311/article/details/122889819
版权

线程池：系列三

阻塞式和定时式那种获取任务方式更好？

Future获取结果的方式有两种

一个是无参的get方法，
  • 它是阻塞式的，获取结果会一直等到结果输出。
  • 案例如下：
  • 先创建任务类
import java.util.concurrent.Callable;

/**
 * @Description Callable任务
 * @ClassName ResultTask
 * @Date 2022/2/9 20:39
 **/
public class ResultTask implements Callable<Integer> {

    public Integer call() throws Exception {
        return 1+1;
    }
}
  • 然后创建单个线程池获取任务结果
import com.naidou.threadPool.tp04.ResultTask;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Description 阻塞式get方法
 * @ClassName ThreadPool04
 * @Date 2022/2/11 21:46
 **/
public class ThreadPool05 {

    public static void main(String[] args) {
        // 创建任务
        com.naidou.threadPool.tp04.ResultTask task = new ResultTask();
        // 创建单个线程的线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        Future<Integer> future = threadPool.submit(task);
        try {
            // 获取任务执行结果
            Integer result = future.get();
            // 输出任务执行结果
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }

    }

}
  • 输出结果：程序正常输出
    在这里插入图片描述
另一个是有参的get方法
  • 我们可以设置获取结果的超时时间，如果大于超时时间，那么程序会抛出TimeoutException异常
    案例如下：
  • 先创建任务类，设置线程休眠时间为3秒
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @Description Callable任务
 * @ClassName ResultTask
 * @Date 2022/2/9 20:39
 **/
public class ResultTask01 implements Callable<Integer> {

    public Integer call() throws Exception {
        // 使当前线程休眠3秒钟
        TimeUnit.SECONDS.sleep(3);
        return 1+1;
    }
}
  • 然后创建单个线程获取任务，先设置获取结果超时时间为1秒
import java.util.concurrent.*;

/**
 * @Description 阻塞式get方法
 * @ClassName ThreadPool04
 * @Date 2022/2/11 21:46
 **/
public class ThreadPool051 {

    public static void main(String[] args) {
        // 创建任务
        ResultTask01 task = new ResultTask01();
        // 创建单个线程的线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        Future<Integer> future = threadPool.submit(task);
        try {
            // 获取任务执行结果
            Integer result = future.get(1,TimeUnit.SECONDS);
            // 输出任务执行结果
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }

    }

}
  • 输出结果：抛出超时异常，符合预期
    在这里插入图片描述
  • 然后设置超时时间为5秒
// 获取任务执行结果
            Integer result = future.get(5,TimeUnit.SECONDS);
  • 输出结果：3秒后程序正常输出，符合预期
    在这里插入图片描述

总结

  • 两种写法都可以，依据不同业务视情况而定，一般用无参方法比较多。

取消任务的cancel方法的一些困惑

cancel(boolean) 取消任务

true：表示尝试中断正在执行任务的线程（只对执行中的任务有意义）
取消正在执行的任务
  • 创建任务类
import java.util.concurrent.Callable;

/**
 * @Description Callable任务
 * @ClassName ResultTask042
 * @Date 2022/2/9 20:39
 **/
public class ResultTask042 implements Callable<Integer> {

    public Integer call() throws Exception {
        // 计数器
        int i = 0;
        // 当线程没被中断时
        while (!Thread.interrupted()){
            // 递增i
            i++;
        }
        // 输出i
        System.out.println("i的值："+i);
        // 返回1+1的值
        return 1+1;
    }
}
  • 线程取消正在执行任务
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Description  取消正在执行的任务
 * @ClassName ThreadPool04
 * @Date 2022/2/11 21:46
 **/
public class ThreadPool042 {

    public static void main(String[] args) {
        // 创建任务
        ResultTask task = new ResultTask();
        // 创建单个线程的线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        Future<Integer> future = threadPool.submit(task);
        System.out.println("任务是否完成：" + future.isDone());
        // 取消任务 调用interrupt打断
        boolean cancel = future.cancel(true);
        System.out.println("任务是否取消成功：" + cancel);
        System.out.println("任务是否取消：" + future.isCancelled());
        try {
            // 获取任务执行结果
            Integer result = future.get();
            // 输出任务执行结果
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}
  • 输出结果：任务取消成功，并引发CancellationException 异常
    在这里插入图片描述
false：则相反
取消未执行任务
  • 创建任务类
import java.util.concurrent.Callable;

/**
 * @Description Callable任务
 * @ClassName ResultTask
 * @Date 2022/2/9 20:39
 **/
public class ResultTask implements Callable<Integer> {

    public Integer call() throws Exception {
        return 1+1;
    }
}
  • 取消未执行任务
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Description 取消未执行任务 引发CancellationException 异常
 * @ClassName ThreadPool04
 * @Date 2022/2/11 21:46
 **/
public class ThreadPool04 {

    public static void main(String[] args) {
        // 创建任务
        ResultTask task = new ResultTask();
        // 创建单个线程的线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        Future<Integer> future1 = threadPool.submit(task);
        Future<Integer> future2 = threadPool.submit(task);
        // 取消任务 调用interrupt打断 取消未执行任务
        boolean cancel = future2.cancel(false);
        System.out.println("任务是否取消成功：" + cancel);
        System.out.println("任务是否取消：" + future2.isCancelled());
        try {
            // 获取任务执行结果
            Integer result = future2.get();
            // 输出任务执行结果
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }

    }
  • 输出结果：任务取消成功，获取结果引发CancellationException 异常
    在这里插入图片描述
取消已完成任务
  • 尝试取消已完成任务
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Description  尝试取消已完成任务
 * @ClassName ThreadPool04
 * @Date 2022/2/11 21:46
 **/
public class ThreadPool041 {

    public static void main(String[] args) {
        // 创建任务
        ResultTask task = new ResultTask();
        // 创建单个线程的线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        Future<Integer> future = threadPool.submit(task);
        try {
            // 获取任务执行结果
            Integer result = future.get();
            // 输出任务执行结果
            System.out.println(result);
            // 取消任务 调用interrupt打断 取消未执行任务
            boolean cancel = future.cancel(false);
            System.out.println("任务是否取消成功：" + cancel);
            System.out.println("任务是否取消：" + future.isCancelled());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }

    }

}
  • 输出结果：已完成任务无法取消
    在这里插入图片描述

总结

在这里插入图片描述

在这里插入图片描述

参考地址

线程池视频讲解05，06

沐子·李
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java自定义任务类定时执行任务示例 callable和future接口使用方法
09-04
4. **Future对象**：通过`Future`接口，我们可以获取到异步计算的结果，检查任务是否完成，取消任务，或者获取任务的执行状态。 下面我们将深入探讨`Callable`和`Future`接口的使用方法。 首先，我们创建一个...
BlockingQueue队列自定义超时时间取消线程池任务
11-25
在超时后，我们可以调用`cancel`方法尝试取消任务，但要注意的是，只有当任务尚未开始执行或者正在执行的任务可以被中断时，`cancel`方法才能成功。 以下是一个简单的示例： ```java ExecutorService executor = ...
线程任务的取消
2301_78064339的博客
06-03 1398
执行任务的线程是由标准的Executor 创建的，它实现了一种中断策略使得任务可以通过中断被取消，所以如果任务在标准Executor中运行，并通过它们的Future 来取消任务，那么可以设置mayInterruptIfRunning。在启动任务线程之后，timedRun将执行一个限时的join 方法。由于调用了阻塞的put 方法，因此这里并不一定需要进行显式的检测，但执行检测却会使PrimeProducer 对中断具有更高的响应性，因为它是在启动寻找素数任务之前检查中断的，而不是在任务完成之后。
java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道？
GitHub质检员
09-02 1449
结合这个需求，我们使用，来对之前学过的知识点做一个回顾，加深记忆。
别告诉我你连线程池都不会用，一文搞懂线程池
最新发布
2401_85767310的博客
06-18 595
不清楚线程池当时的情况，有多少线程在执行，多少在队列中等待呢？创建了一个ThreadPoolTaskExecutor的子类，在每次提交线程任务的时候都会将当前线程池的运行状况打印出来return;prefix,@Override@Override@Override@Override@Override@Override复制代码。
多线程执行任务，并获取结果
GONGJ79的博客
07-04 198
多线程执行任务，并获取结果。
Java的Future 详解，获取线程池执行结果
没有伞的孩子必须努力奔跑！—小林
03-03 4761
1. Future的应用场景 在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。 Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功...
可执行任务取消处理线程池
gongbenwen的专栏
10-23 3803
周末闲来无事，把思考了很久的一个线程池处理算法，实现了，总结了一下设计的思路和设计的初衷。 在进行多线程异步任务调用时，我们经常会用到.net中的线程池System.Threading.ThreadPool.QueueUserWorkItem，随着微软在线程池调度算法上的优化，线程池的效率和智能化等方面，越来越高，但是该线程池，也存在操作的缺陷，比如发起一个异步的大数据保存操作，执行数据保存可能
Java线程池学习资料-全
08-11
`cancel()`方法用于取消任务，只是简单地改变任务状态，如果需要中断任务执行线程，则会调用`Thread.interrupt()`。 `execute()`和`submit()`方法是线程池提交任务的两种方式。`execute()`接受`Runnable`对象，而`...
Java中Future、FutureTask原理以及与线程池的搭配使用
08-25
`ExecutorService`执行这个`RunnableFuture`，任务完成后，结果可通过`Future`的`get()`方法获取。 `ExecutorService`的`submit()`方法有三个重载版本： 1. `Future<?> submit(Runnable task)`：将`Runnable`包装为...
Java面向对象系列[v1.0.0][线程池]
12-21
`Future`接口提供了`get()`方法用于阻塞等待任务完成并获取结果，`cancel(boolean mayInterruptIfRunning)`方法用于取消任务的执行。 总之，Java的线程池机制是通过优化线程的生命周期管理和并发控制，来提高系统...
java线程池批量异步执行方法，获取返回值
qq_41028058的博客
10-27 3925
java指定线程池批量异步执行方法，获取返回值
Java并发编程——线程池的使用（三）线程池执行任务、取消任务
h610968110的博客
12-25 6427
一、线程池执行Runnable任务 executor.execute(runnable) executor.execute(new Runnable() { @Override public void run() { System.out.println("执行任务"); }
Java多线程，获取线程池中线程的返回结果
m0_46340675的博客
08-03 1032
Future类的get()方法会阻塞主线程，导致多线程执行变成了单线程。
【自省】线程池里的定时任务跑的可欢了，可咋停掉特定的任务？
m0_74931226的博客
12-23 4213
使用 ScheduledExecutorService#scheduleAtFixedRate来实现定时任务，它的运行机制大概是这样： 如果上一个任务的执行时间大于等待时间，任务结束后，下一个任务马上执行。 如果上一个任务的执行时间小于等待时间，任务结束后，下一个任务在（间隔时间-执行时间）后开始执行。
java线程-如何优雅地获取线程的执行结果
m0_71777195的博客
07-20 612
java复制代码// 取消任务// 判断任务是否已取消// 判断任务是否已结束// 获得任务执行结果 阻塞，被调用时，如果任务还没有执行完，那么调用get()方法的线程会阻塞。直到任务执行完// 才会被唤醒get();// 获得任务执行结果，支持超时用来取消异步任务的执行。如果异步任务已经完成或者已经被取消，或者由于某些原因不能取消，则会返回false。如果任务还没有被执行，则会返回true并且异步任务不会被执行。
Java多线程获取执行结果
wangwenzhe的博客
09-20 2753
System.out.println("仓库满了============================================");System.out.println("仓库空了============================================");1、线程安全，生产者与消费者分别执行读写操作，特别是在多个生产线程与消费线程时，一定会存在数据读写的并发操作，所以数据队列一定要保证线程安全；
java获取线程池执行完后的结果
yinxianluo的专栏
03-25 620
person.setName("张三");
取消正在执行的线程
知道这个有什么用？
09-02 877
开一个线程，执行一个任务：计算1000000033是不是质数，2秒后取消这个任务。真的是：不试不知道，一试吓一跳！！！
springboot ThreadPoolTaskScheduler 获取执行的方法
06-07
除了 isRunning 方法外，ScheduledFuture 还提供了其他方法，例如 get、getDelay 和 cancel 等，可以用于获取执行结果、获取任务的延迟时间和取消任务的执行。需要根据实际需求选择合适的方法来使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值