jdk 8-future 异步处理-轮询isDone判断完成-springBoot示例

最新推荐文章于 2023-05-18 22:28:06 发布
最新推荐文章于 2023-05-18 22:28:06 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： demo springboot Java 文章标签： java spring boot future 异步 jdk8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/privateobject/article/details/126049344
版权
demo 同时被 3 个专栏收录
32 篇文章 0 订阅
订阅专栏
Java
29 篇文章 0 订阅
订阅专栏
springboot
23 篇文章 0 订阅
订阅专栏

Future接口用于获取异步计算的结果，可通过get()获取结果、cancel()取消、isDone()判断是否完成等操作。
V get()： 获取结果，若无结果会阻塞至异步计算完成
V get(long timeOut, TimeUnit unit)：获取结果，超时返回null
boolean isDone()：执行结束（完成/取消/异常）返回true
boolean isCancelled()：任务完成前被取消返回true
boolean cancel(boolean mayInterruptRunning)：取消任务，未开始或已完成返回false，参数表示是否中断执行中的线程
java的Timer类来进行定时调用，schedule(TimerTask task, long delay)调度一个task，经过delay(ms)后开始进行调度，仅仅调度一次

参考

在 Java Future 上使用带有 isDone 和 Cancel 的轮询而不是阻塞 get
Future的isDone()方法结果为true代表了什么？
java Timer（定时调用、实现固定时间执行）
Java之Future（cancel，iSDone）
Java多线程任务超时结束的5种实现方法

操作

pom

    <!--基于Springboot-->
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.1.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <skipTests>true</skipTests>

        <spring-boot.version>2.3.1.RELEASE</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

java测试代码

package ***.cfg;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * ExecutorPoolConfig 类说明:
 *
 * @author z.y
 * @version v1.0
 * @date 2022/7/27
 */
@Order
@Configuration
public class ExecutorPoolConfig {
    private static final Logger log = LoggerFactory.getLogger(ExecutorPoolConfig.class);
    @Bean ("taskNotifyThread")
    public AsyncTaskExecutor taskNotifyThread(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(10);
        executor.setKeepAliveSeconds(60);
        executor.setQueueCapacity(1);
        executor.setThreadNamePrefix("TASK-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        executor.initialize();
        log.info("线程池-初始化");
        return executor;
    }
    public void testPool(int size){
        try {
            size = Math.max(4,size);
            log.info("开始测试 线程池，数量 {}",size);
            AsyncTaskExecutor executor = taskNotifyThread();
            Map<String, Future<Boolean>> map = new HashMap<>(size);
            for (int i = 0; i < size; i++) {
                int index = i;
                map.put("T-"+index,executor.submit(() -> testOne(index)));
            }
            log.info("任务 已提交 线程池，数量 {}",size);
            Set<String> keySet = map.keySet();
            List<String> doneList = new ArrayList<>(size);
            // 方式1 使用 get 阻塞判断否结束--------------
            Boolean b;
            for (String key : keySet) {
                b = map.get(key).get();
                if(null != b){
                    log.info("get 阻塞判断是否结束,{}",b);
                    doneList.add(key);
                }
            }
            // 方式1 使用 get 阻塞判断是结束--------------

            // 方式2 使用 isDone 轮询判断是结束---------------
            Future<Boolean> future;
            while (keySet.size() != doneList.size()){
                for (String key : keySet) {
                    // 已结束的子任务 直接跳过
                    if(doneList.contains(key)){ continue; }
                    future = map.get(key);
                    if(future.isDone()){
                        doneList.add(key);
                        log.info("子任务已结束,{},{}",key,future.get());
                    }else{
                        log.info("子任务未结束-===-{}",key);
                    }
                }
                log.info("问了一遍,结束的任务:{},先睡1s",doneList);
                TimeUnit.SECONDS.sleep(1);
            }
            // 方式2 使用 isDone 轮询判断是结束---------------
            log.info("都已经处理结束,结束的顺序:{}",doneList);
        }catch (Exception e){
            log.error("任务测试失败",e);
        }
    }
    private Boolean testOne(int index){
        try {
            int i = ThreadLocalRandom.current().nextInt(2,10);
            log.info("子任务-{}-开始,睡眠:{}",index,i);
            TimeUnit.SECONDS.sleep(i);
            log.info("子任务-{}=====结束,睡眠:{}",index,i);
            return i % 2 == 0;
        }catch (Exception e){
            log.error("子任务测试失败",e);
        }
        return false;
    }
    @PostConstruct
    public void init(){
        log.info("配置类初始化完成");
        new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                log.info("线程池开始处理");
                testPool(6);
            }
        }, 2000);
    }
}

在这里插入图片描述

日志

方式2-轮询处理

2022-07-28 08:54:55.722  INFO 17952 --- [           main] ***.cfg.ExecutorPoolConfig  : 线程池-初始化
2022-07-28 08:54:55.723  INFO 17952 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'taskNotifyThread'
2022-07-28 08:54:55.992  INFO 17952 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 9980 (http) with context path '/runner-demo'
2022-07-28 08:54:56.002  INFO 17952 --- [           main] ***.RunnerSpringDemoApplication      : Started RunnerSpringDemoApplication in 2.32 seconds (JVM running for 4.784)
2022-07-28 08:54:56.004  INFO 17952 --- [           main] ***.RunnerSpringDemoApplication      : http://127.0.0.1:9980/runner-demo/
2022-07-28 08:54:57.714  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 线程池开始处理
2022-07-28 08:54:57.714  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 开始测试 线程池，数量 6
2022-07-28 08:54:57.715  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 任务 已提交 线程池，数量 6
2022-07-28 08:54:57.716  INFO 17952 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-4-开始,睡眠:2
2022-07-28 08:54:57.716  INFO 17952 --- [         TASK-3] ***.cfg.ExecutorPoolConfig  : 子任务-3-开始,睡眠:3
2022-07-28 08:54:57.716  INFO 17952 --- [         TASK-5] ***.cfg.ExecutorPoolConfig  : 子任务-5-开始,睡眠:9
2022-07-28 08:54:57.716  INFO 17952 --- [         TASK-1] ***.cfg.ExecutorPoolConfig  : 子任务-0-开始,睡眠:2
2022-07-28 08:54:57.716  INFO 17952 --- [         TASK-2] ***.cfg.ExecutorPoolConfig  : 子任务-2-开始,睡眠:4
2022-07-28 08:54:57.716  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-2
2022-07-28 08:54:57.716  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:54:57.716  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-4
2022-07-28 08:54:57.716  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-3
2022-07-28 08:54:57.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:54:57.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-0
2022-07-28 08:54:57.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[],先睡1s
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-2
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-4
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-3
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-0
2022-07-28 08:54:58.717  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[],先睡1s
2022-07-28 08:54:59.717  INFO 17952 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-4=====结束,睡眠:2
2022-07-28 08:54:59.717  INFO 17952 --- [         TASK-1] ***.cfg.ExecutorPoolConfig  : 子任务-0=====结束,睡眠:2
2022-07-28 08:54:59.717  INFO 17952 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-1-开始,睡眠:4
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-2
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-4,true
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-3
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-0,true
2022-07-28 08:54:59.718  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0],先睡1s
2022-07-28 08:55:00.717  INFO 17952 --- [         TASK-3] ***.cfg.ExecutorPoolConfig  : 子任务-3=====结束,睡眠:3
2022-07-28 08:55:00.719  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-2
2022-07-28 08:55:00.719  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:55:00.719  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-3,false
2022-07-28 08:55:00.719  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:00.719  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3],先睡1s
2022-07-28 08:55:01.716  INFO 17952 --- [         TASK-2] ***.cfg.ExecutorPoolConfig  : 子任务-2=====结束,睡眠:4
2022-07-28 08:55:01.720  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-2,true
2022-07-28 08:55:01.720  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:55:01.720  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:01.720  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2],先睡1s
2022-07-28 08:55:02.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-1
2022-07-28 08:55:02.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:02.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2],先睡1s
2022-07-28 08:55:03.718  INFO 17952 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-1=====结束,睡眠:4
2022-07-28 08:55:03.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-1,true
2022-07-28 08:55:03.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:03.721  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2, T-1],先睡1s
2022-07-28 08:55:04.722  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:04.722  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2, T-1],先睡1s
2022-07-28 08:55:05.723  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务未结束-===-T-5
2022-07-28 08:55:05.723  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2, T-1],先睡1s
2022-07-28 08:55:06.716  INFO 17952 --- [         TASK-5] ***.cfg.ExecutorPoolConfig  : 子任务-5=====结束,睡眠:9
2022-07-28 08:55:06.723  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 子任务已结束,T-5,false
2022-07-28 08:55:06.723  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 问了一遍,结束的任务:[T-4, T-0, T-3, T-2, T-1, T-5],先睡1s
2022-07-28 08:55:07.724  INFO 17952 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 都已经处理结束,结束的顺序:[T-4, T-0, T-3, T-2, T-1, T-5]

方式1-阻塞获取

--2022-07-29 10:19:25.436 - INFO 19288 --- [           main] ***.cfg.ExecutorPoolConfig  : 线程池-初始化
--2022-07-29 10:19:25.438 - INFO 19288 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'taskNotifyThread'
--2022-07-29 10:19:25.819 - INFO 19288 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 9980 (http) with context path '/runner-demo'
--2022-07-29 10:19:25.831 - INFO 19288 --- [           main] ***.RunnerSpringDemoApplication      : Started RunnerSpringDemoApplication in 3.103 seconds (JVM running for 6.078)
--2022-07-29 10:19:25.834 - INFO 19288 --- [           main] ***.RunnerSpringDemoApplication      : http://127.0.0.1:9980/runner-demo/
--2022-07-29 10:19:27.424 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 线程池开始处理
--2022-07-29 10:19:27.424 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 开始测试 线程池，数量 6
--2022-07-29 10:19:27.427 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 任务 已提交 线程池，数量 6
--2022-07-29 10:19:27.427 - INFO 19288 --- [         TASK-5] ***.cfg.ExecutorPoolConfig  : 子任务-5-开始,睡眠:6
--2022-07-29 10:19:27.427 - INFO 19288 --- [         TASK-2] ***.cfg.ExecutorPoolConfig  : 子任务-2-开始,睡眠:2
--2022-07-29 10:19:27.427 - INFO 19288 --- [         TASK-1] ***.cfg.ExecutorPoolConfig  : 子任务-0-开始,睡眠:7
--2022-07-29 10:19:27.427 - INFO 19288 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-4-开始,睡眠:2
--2022-07-29 10:19:27.427 - INFO 19288 --- [         TASK-3] ***.cfg.ExecutorPoolConfig  : 子任务-3-开始,睡眠:7
--2022-07-29 10:19:29.429 - INFO 19288 --- [         TASK-2] ***.cfg.ExecutorPoolConfig  : 子任务-2=====结束,睡眠:2
--2022-07-29 10:19:29.429 - INFO 19288 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-4=====结束,睡眠:2
--2022-07-29 10:19:29.429 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,true
--2022-07-29 10:19:29.429 - INFO 19288 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-1-开始,睡眠:3
--2022-07-29 10:19:32.430 - INFO 19288 --- [         TASK-4] ***.cfg.ExecutorPoolConfig  : 子任务-1=====结束,睡眠:3
--2022-07-29 10:19:32.430 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,false
--2022-07-29 10:19:32.431 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,true
--2022-07-29 10:19:33.429 - INFO 19288 --- [         TASK-5] ***.cfg.ExecutorPoolConfig  : 子任务-5=====结束,睡眠:6
--2022-07-29 10:19:34.429 - INFO 19288 --- [         TASK-1] ***.cfg.ExecutorPoolConfig  : 子任务-0=====结束,睡眠:7
--2022-07-29 10:19:34.429 - INFO 19288 --- [         TASK-3] ***.cfg.ExecutorPoolConfig  : 子任务-3=====结束,睡眠:7
--2022-07-29 10:19:34.429 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,false
--2022-07-29 10:19:34.429 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,true
--2022-07-29 10:19:34.429 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : get 阻塞判断是否结束,false
--2022-07-29 10:19:34.429 - INFO 19288 --- [        Timer-0] ***.cfg.ExecutorPoolConfig  : 都已经处理结束,结束的顺序:[T-2, T-1, T-4, T-3, T-5, T-0]
-

结束

get阻塞方式，任务不是最早结束的就能得到结果值，是按照自定义key的 顺序获取结果。
isDone轮询方式，任务是在主线程循环判断，结果顺序是和任务耗时有关，代码较多。
个人见解，如有问题请指出。

privateobject
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程系列--掌握Future，轻松获取异步任务结果
leobert.lan的博客
09-26 1272
连这些读不知道的话，面试肯定要挂了。 今天，我们一同回顾：多线程中并发和异步的基础中的基础，掌握了它们才有面试及格的可能。
jdk-8u231-linux-x64.tar.gz
10-23
jdk-8u231-linux-x64.tar.gz JDK for linux x64 tar.gz 大小：185.16 MB sha256: a011584a2c9378bf70c6903ef5fbf101b30b08937441dc2ec67932fb3620b2cf md5: c1fef2e714be761773ee0fc2be5dd78e
Future 总结
toneylyx的博客
03-21 327
1. 关于FutureFuture接口包含以下方法： boolean cancel(boolean mayInterruptIfRunning)*取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束 boolean isCancelled() *任务是否已经取消，任务正常完成前将其取消，则返回 true boolean isDone()*任务是否已经完成。需要注意的是如果任务正常
17.Future 介绍与主要用法
daohangtaiqian的博客
03-17 2299
Future 最主要的作用是
Future的isDone()方法结果为true代表了什么？
绅士jiejie的博客
04-24 1万+
先写个Future调用isDone()方法，返回结果是正常的示例 public class SpringbootApplication { //构建一个线程任务 static class DoSomeThing implements Callable { @Override public Object call() throws Excepti...
ThreadPoolExecutor 判断多线程执行完成
java、c++、机器学习方向King
03-07 2万+
1. public boolean isEndTask() {       while (true) {         if (this.ThreadPoolExecutor.getActiveCount() == 0) {           return true;            }          }     }       if (isEndTask())
【Springboot中的异步方法、定时任务、方法重试】
qq_43495421的博客
05-18 1180
本文主要记录下Springboot中异步方法，定时任务以及方法重试的使用，异步方法，定时任务以及方法重试在项目中还是经常会使用到的，使用的方式也比较简单，通过本文可以实现基本的使用，自己的学习笔记，如有错误请多指正。
通俗易懂：什么是Future.get()的阻塞等待？有什么解决方法？
Tech in Pieces
12-05 2万+
先说说Future。 他是一个interface 也可以理解为一种设计模式。 大致如下：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。就是我之前所理解的异步。 Future提供了三个功能： 判断任务是否完成 isDone(): get results not done: keep waiting?kill it? Future里面有个方法 get 是个阻塞方法。当线程池一次性submit多个任务的时候。
springboot-javafx-support:SpringBoot JavaFX8 集成
08-04
springboot-javafx-support 注意：当前 master 是针对 Spring Boot 2 和 Spring Framework 5。 最新的生产就绪版本： 对于 Spring Boot 1.5.x 是 1.4.5。 （生命尽头！） 对于 Spring Boot 2.x 是 2.1.6。 ...
jdk-8u251-windows-x64.exe
04-15
jdk8u251最新的windows系统安装包64位安装包 官网登录页面总是上不去 好不容易下来的分享给大家 希望能帮到大家
使用异步方式查询数据库记录
12-14
使用异步方式查询数据库记录
jdk-8u201-linux-x64.tar.gz jdk8版本下载
07-01
对于名为“jdk-8u201-linux-x64.tar.gz”的压缩包，它是专为64位Linux系统设计的。要安装这个JDK，你需要按照以下步骤操作： 1. **下载**：你可以通过Oracle官网或者第三方镜像站点下载到这个文件。在Linux终端中，...
jdk-8u201-windows-x64
01-17
"jdk-8u201-windows-x64" 版本是针对Windows 64位操作系统的JDK 8的更新版本201。在Java开发中，JDK起着至关重要的作用，因为它是整个Java生态系统的基础。 1. **Java编程语言**: JDK 8是基于Java编程语言的，这是...
FutureTask isDone 返回 false
烤鸭的世界我们不懂的博客
07-07 1327
大家好，我是烤鸭： ​     今天看一下 FutureTask源码。好吧，其实遇到问题了，哪里不会点哪里。 伪代码 package src.executor; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.c
java 多线程 submit future.get方法阻塞问题的解决，实现按照任务完成的先后顺序获取任务的结果
You can walk as far as you want.
02-03 4647
1、Future Future模式是多线程设计常用的一种设计模式。Future模式可以理解成：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。 Future提供了三种功能： 判断任务是否完成 能够中断任务 能够获取任务执行的结果 向线程池中提交任务的submit方法不是阻塞方法，而Future.get方法是一个阻塞方法，当submit提交多个任务时，只有所有任务都完成后，才能使用get按照任务的提交顺序
channelFuture 用法 isDone isSuccess
yaobo2816的专栏
10-13 7558
项目里遇见一个问题，使用channelFuture 接口用到operateComplete的时候，遇见一个问题，当用netty 发送消息的时候，成功与否的时候用到了 isSuccess,但是当netty发送数据异常的时候，客户端假死，没有反应，经过分析把isSuccess改成了isDone解决了问题。 查了文档分析如下
java 实现长轮询(LongPolling)
qq_18478183的博客
10-04 4658
长轮询java代码实现，观察者模式，门面模式
JAVA Future类详解
热门推荐
时光钟摆
06-06 20万+
在并发编程中，我们经常用到非阻塞的模型，在之前的多线程的三种实现中，不管是继承thread类还是实现runnable接口，都无法保证获取到之前的执行结果。通过实现Callback接口，并用Future可以来接收多线程的执行结果。
java8的list分组-类字段分组-及分组后排序
privateobject的博客
08-16 1万+
jdk8(java8)，list 集合 分组，stream 流处理，groupingBy 使用 两种分组方式的代码 参考 Stream流使用groupingBy+mapping实现对分组之后的对象集合转化为对象的某个属性的集合 测试代码 import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; /**.
jdk1.8-8u241 下载
最新发布
08-01
JDK 1.8 - 8u241是Java Development Kit（Java开发工具包）的一个版本，用于开发和运行Java应用程序的工具包。用户可以从Oracle官方网站上下载此版本的JDK。 首先，访问Oracle官方网站（https://www.oracle.com/java/technologies/javase-jdk8-downloads.html）并找到JDK 1.8 - 8u241的下载页面。 在下载页面上，选择适合您操作系统的版本，例如Windows、macOS或Linux。然后，单击下载按钮开始下载。 下载过程可能需要一些时间，取决于您的网络连接速度和计算机性能。请耐心等待下载完成。 下载完成后，您可以找到下载的安装文件并双击运行它。按照安装向导的指示，选择您希望安装JDK的位置和其他选项。 完成安装后，您可以在安装目录中找到JDK的文件和文件夹。您可以在命令提示符下运行Java编译器（javac）和Java虚拟机（java）来编译和运行您的Java程序。 总结来说，下载JDK 1.8 - 8u241需要访问Oracle官方网站，找到适合您操作系统的版本，然后下载并按照安装向导进行安装。安装完成后，您就可以开始使用JDK来开发和运行Java应用程序了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值