并发编程之五FutureTask

已于 2023-04-15 21:35:41 修改
阅读量514 收藏
点赞数
分类专栏： 并发编程 文章标签： java jvm servlet
于 2023-04-15 12:18:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43476824/article/details/130167452
版权

futureTask实现了Runnable, Future接口，Future接口有如下定义：

    /**
     * 取消任务，如果任务已经在执行，mayInterruptIfRunning为true，则
     * 向执行线程发送interrupt事件，否则任由任务执行完毕。
     * 返回值为是否取消成功
     */
    boolean cancel(boolean mayInterruptIfRunning);

    // 任务是否已经被取消
    boolean isCancelled();

    // 任务是否已经执行完毕
    boolean isDone();

    /** 
     * 等待并获取结果，会抛出以下异常
     * 1. CancellationException 任务被取消
     * 2. ExecutionException 任务执行异常
     * 3. InterruptedException 执行线程在等待时收到interrupted事件
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an
     * exception
     * @throws InterruptedException if the current thread was interrupted
     * while waiting
     * @throws TimeoutException if the wait timed out
     */
    /** 
     * 等待并获取结果，timeout是最大等待时间，会抛出以下异常
     * 1. CancellationException 任务被取消
     * 2. ExecutionException 任务执行异常
     * 3. InterruptedException 执行线程在等待时收到interrupted事件
     * 4. 等待超时
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;

1. isDone示例

package org.example.concurrent;

import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.Test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

import static org.assertj.core.api.Assertions.assertThat;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask running");
            return "ok";
        });

        // 提交线程池之前，futureTask的状态为未执行
        assertThat(futureTask).isNotDone();
        executorService.execute(futureTask);

        // 等待100ms后，执行成功
        assertThat(futureTask).succeedsWithin(100L, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.STRING)
                .contains("ok");
    }
}

2. cancel和 isCancelled

2.1 任务执行前cancel

示例：

package org.example.concurrent;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask running");
            return "ok";
        });

        // 任务执行前cancel
        futureTask.cancel(false);
        assertThat(futureTask).isCancelled().isNotDone();
        executorService.execute(futureTask);

        // 取消的任务get会报取消异常
        assertThatExceptionOfType(CancellationException.class).isThrownBy(futureTask::get);
        
        // get后futureTask变为isDone;
        assertThat(futureTask).isCancelled().isDone();
    }
}

2.2 任务执行中取消任务

    示例1：取消，不通知任务线程中断

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.*;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @SneakyThrows
    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask start");
            sleep(300L);
            log.debug("futureTask end");
            return "ok";
        });
        executorService.execute(futureTask);

        // 等待100毫秒，此时futureTask正在运行, 然后取消任务
        sleep(100L);
        futureTask.cancel(false);

        // 取消的任务get会报取消异常
        assertThatExceptionOfType(CancellationException.class).isThrownBy(futureTask::get);

        // get后futureTask变为isDone;
        assertThat(futureTask).isCancelled().isDone();

        // 继续等待1秒，会发现任务会执行完毕
        sleep(1000L);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行日志：

11:53:58.340 [pool-1-thread-1] DEBUG o.example.concurrent.FutureTaskTest - futureTask start
11:53:58.649 [pool-1-thread-1] DEBUG o.example.concurrent.FutureTaskTest - futureTask end

示例2：取消并通知任务线程中断（如果线程处于阻塞中，会感知到自身中断）

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.*;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @SneakyThrows
    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask start");
            try {
                sleep(300L);
            } catch (Exception e) {
                // 捕获打印异常名称并重新抛出
                log.error("catch Exception:{}", e.getClass().getSimpleName());
                throw e;
            }
            log.debug("futureTask end");
            return "ok";
        });
        executorService.execute(futureTask);

        // 等待100毫秒，此时futureTask正在运行, 然后取消任务
        sleep(100L);
        futureTask.cancel(true);

        // 取消的任务get会报取消异常
        assertThatExceptionOfType(CancellationException.class).isThrownBy(futureTask::get);

        // get后futureTask变为isDone;
        assertThat(futureTask).isCancelled().isDone();

        // 继续等待1秒，会发现任务会执行完毕
        sleep(1000L);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

执行过程中，futureTask执行线程处于休眠中，能够感知到线程中断，执行结果如下：

11:59:10.410 [pool-1-thread-1] DEBUG o.example.concurrent.FutureTaskTest - futureTask start
11:59:10.513 [pool-1-thread-1] ERROR o.example.concurrent.FutureTaskTest - catch Exception:InterruptedException
11:59:10.515 [pool-1-thread-1] DEBUG o.example.concurrent.FutureTaskTest - futureTask end

示例3：重复取消任务，会取消失败

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.*;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @SneakyThrows
    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask start");
            sleep(300L);
            log.debug("futureTask end");
            return "ok";
        });
        executorService.execute(futureTask);

        // 等待100毫秒，
        sleep(100L);

        // 此时futureTask正在运行, 然后取消任务, 如果重复取消，会返回失败
        assertThat(futureTask.cancel(false)).isTrue();
        assertThat(futureTask.cancel(false)).isFalse();

        // 取消的任务get会报取消异常
        assertThatExceptionOfType(CancellationException.class).isThrownBy(futureTask::get);
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

2.3 任务执行完成后cancel

        任务执行完毕后在取消任务执行，取消动作会失败。参考下面的代码：

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.assertj.core.api.InstanceOfAssertFactories;
import org.junit.Test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

import static org.assertj.core.api.Assertions.assertThat;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @SneakyThrows
    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask start");
            log.debug("futureTask end");
            return "ok";
        });
        executorService.execute(futureTask);

        // 等待100毫秒，此时futureTask已经执行完毕, 取消任务执行会失败
        sleep(100L);
        assertThat(futureTask.cancel(true)).isFalse();

        // 判断执行成功
        assertThat(futureTask).succeedsWithin(0L, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.STRING)
                .contains("ok");
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

3. get等待指定时间

get指定最大等待时间，如果超出此时间，则会抛出TimeoutException异常：

package org.example.concurrent;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.concurrent.*;

import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

@Slf4j
public class FutureTaskTest {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

    @SneakyThrows
    @Test
    public void test() {
        FutureTask<String> futureTask = new FutureTask<>(() -> {
            log.debug("futureTask start");
            sleep(1000L);
            log.debug("futureTask end");
            return "ok";
        });
        executorService.execute(futureTask);

        // get等待10毫秒，由于futureTask会执行1秒钟，get会报超时异常
        assertThatExceptionOfType(TimeoutException.class).isThrownBy(() -> futureTask.get(10L, TimeUnit.MILLISECONDS));
    }

    @SneakyThrows
    private void sleep(long delay) {
        TimeUnit.MILLISECONDS.sleep(delay);
    }
}

不听话的小耳朵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并发编程笔记20190526.docx
07-01
4、Callable、Future和FutureTask 30 5、原子操作CAS (compare atomic swap) 32 三、显式锁和AQS 34 1、AQS定义两种资源共享方式： 34 2、深入源码 37 3、了解Condition的实现 42 4、 锁的可重入 44 第三章 并发容器...
对话框拦截控件消息
qq_32563489的博客
09-10 319
BOOL CQuickMosaicDlg::PreTranslateMessage(MSG* pMsg) { if (pMsg->message==WM_KEYDOWN) //键盘按下 { if (pMsg->hwnd==GetDlgItem(IDC_DATALIST)->m_hWnd) { switch (pMsg->wParam) { case 'A'://A键
FutureTask类（源码解读）
Anakki的博客
08-24 1248
目录 一.源码解读 1.1 FutureTask(Callable callable) 1.2 FutureTask(Runnable runnable, V result) 1.3 FutureTask类的一些常量和属性 1.3.1 任务当前状态 state 1.3.2 任务7种状态属性： 1.3.3 存放返回结果 outcome： 1.3.4 指向传入的实现了Callable接...
执行器中取消任务
西木空间
11-27 217
Java 9并发编程指南 目录 执行器中取消任务准备工作实现过程工作原理扩展学习更多关注 当用执行器开发时，不需要管理线程，只要实现Runnable或Callable任务且发送给执行器。执行器的任务是创建线程，在线程池中管理线程，如果不需要的话则结束线程。有时可能会取消发送给执行器的任务，这种请款下， 使用Future的cancel()方法，允许你进行取消操作。本届中，学习如何使用此方法取消已经发...
FutureTask详解
热门推荐
做一个有思想的技术人
06-03 9万+
FutureTask介绍 一个可取消的异步计算。FutureTask提供了对Future的基本实现，可以调用方法去开始和取消一个计算，可以查询计算是否完成并且获取计算结果。只有当计算完成时才能获取到计算结果，一旦计算完成，计算将不能被重启或者被取消，除非调用runAndReset方法。 除了实现了Future接口以外，FutureTask还实现了Runnable FutureTask使用 Futu......
并发编程_模式开发模式.pdf
10-07
在并发编程中，模式开发是解决多线程间协作与通信的关键。本文件主要讨论了“保护性暂停”模式，这是一种同步模式，用于确保线程安全地交换数据或等待特定条件满足后再继续执行。保护性暂停模式的核心在于，当一个...
Java 并发编程实战
05-21
5.5.2　FutureTask 5.5.3　信号量 5.5.4　栅栏 5.6　构建高效且可伸缩的结果缓存 第二部分　结构化并发应用程序 第6章　任务执行 6.1　在线程中执行任务 6.1.1　串行地执行任务 6.1.2　显式地为任务创建线程 6.1.3　...
Java并发编程原理与实战
08-14
提前完成任务之FutureTask使用.mp4 Future设计模式实现（实现类似于JDK提供的Future）.mp4 Future源码解读.mp4 ForkJoin框架详解.mp4 同步容器与并发容器.mp4 并发容器CopyOnWriteArrayList原理与使用.mp4 并发容器...
java并发编程
03-22
第42节提前完成任务之FutureTask使用00:11:43分钟 | 第43节Future设计模式实现（实现类似于JDK提供的Future）00:19:20分钟 | 第44节Future源码解读00:29:22分钟 | 第45节Fork/Join框架详解00:28:09分钟 | 第46节...
多线程学习六：Future与FutureTask
dulixing0154084的博客
11-15 275
FutureTask是Future接口的一个唯一实现类，可以作为Runnable被线程执行，也可以作为Future得到Callable的返回值。 Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。Future类位于java.util.concurrent包下，它是一个接口...
java scheduledfuture_几种定时任务（Timer、TimerTask、ScheduledFuture）的退出—结合真实案例【JAVA并发】...
weixin_30089411的博客
02-13 5006
工作中常常会有定时任务的开发需求，特别是移动端。最近笔者正好有所涉及，鉴于此，结合开发中的案例说明一下几种定时任务的退出。需求说明：定时更新正在生成的文件大小和状态【进行中、失败、完成】，如果文件生成完成，则退出【CoderBaby】调度可以用Timer【调用schedule()或者scheduleAtFixedRate()方法实现】或者ScheduledExecutorService【结合工作中...
5 - 线程池 Java内置的线程池 - 异步计算结果（Future）
xiaozhou的博客
12-12 699
Java内置的线程池 - 异步计算结果（Future）
Java常见面试题—Future与FutureTask
wmingstar
09-01 6953
FutureFuture就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果等操作。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。 Future类位于java.util.concurrent包下，它是一个接口：/** * @see FutureTask * @see Executor * @since 1.5 * @a
Java 多线程使用以及锁机制
Leo_Liang_jie的博客
05-29 1097
Java开启线程，用来执行异步功能，废话少说，直接上第一种方式： 方式1：new Thread() new Thread(new Runnable() { @Override public void run() { String name = Thread.currentThread().getName(); ...
FutureTask的cancel方法真的能停止掉一个正在执行的异步任务吗
u014644574的博客
03-03 2188
ExecutorService executor = Executors.newSingleThreadExecutor(); FutureTask<?> futureTask = new FutureTask<String>(new Callable<String>() { @Override public String call() throws Exception { ...
（Java并发基础）Future类的使用
gonghaiyu的博客
09-30 1180
在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。 Callable接口 public interface Callable<V> { V call() throws Exception; } 可以看出它也是一个 interface，并且它的 call 方法中已经声明了 throws Exception，前面
future cancel失败一例
nailgo的专栏
07-13 1741
由于future线程中任务执行时间比较长，有时候想停都停不下来。所以搞了个static的map：futureMap存放future对象，创建的时候put进去，然后前台通过调用取消接口，调用下面方法对线程进行中断。 publicStringcancelFuture(inttaskId){ try{ booleancancelFlag=futureMap.get(taskId).cancel(true); logger.info(...
FutureTask介绍及使用
闵浮龙的博客
03-31 4万+
Future Future是一个接口，它定义了5个方法： boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; 简单说明一下接口定义 boolean can...
FutureTask
最新发布
09-01
FutureTask是Java中的一个类，用于将异步操作封装成一个可获取结果的任务。它实现了Java中的Future接口，可以用于提交给线程池...FutureTask常用于多线程编程中，可以通过它来获取并发任务的执行结果，提高程序的效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值