Future

最新推荐文章于 2024-06-21 22:23:19 发布
最新推荐文章于 2024-06-21 22:23:19 发布
阅读量339 收藏 7
点赞数 6
分类专栏： java 并发编程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34250794/article/details/136393249
版权

Future

一、

package com.android.arthogritybrary;

import java.util.concurrent.Callable;

public class RealData implements Callable<String> {
    private String para;

    public RealData(String para) {
        this.para = para;
    }

    @Override
    public String call() throws Exception {
        StringBuffer stringBuffer = new StringBuffer(para);
        for (int i = 0; i < 10; i++) {
            stringBuffer.append(i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return stringBuffer.toString();
    }
}


package com.android.arthogritybrary;

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

//zsg

/**
 * Future模式是多线程开发中非常常见的一种设计模式，它的核心思想是异步调用。
 * 当我们需要调用一个函数时，如果这个函数执行得很慢，那么我们就要等待。
 * 但有时候，我们可能并不急着要结果。因此，我们可以让被调者立即返回，让它在后台慢慢处理这个请求。
 * 对于调用者来说，则可以先处理一些其他任务，在真正需要数据的场合再去尝试获得需要的数据。
 *
 * 立即返回的相当于网购订单,真实的商品会在一段耗时之后完成,在这期间你可以做其他任务。
 */

public class FutureMain {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //zsg 这里尖括号里的类型就说明了 提交的任务返回的是什么类型
        FutureTask<String> futureTask = new FutureTask<String>(new RealData("a"));
        ExecutorService threadPool = Executors.newFixedThreadPool(1);
        //提交任务执行RealData里的call方法
        threadPool.submit(futureTask);
        System.out.println("请求完成");

        try {
            //zsg 假设在做其他任务
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //如果call方法还没执行完会阻塞
        System.out.println("数据= "+futureTask.get());
    }
}

二、Futurelistener 任务完成了可以通知你

package com.android.arthogritybrary;

import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

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

/**
 * 在JDK自带的简单Future模式中，虽然我们可以使用future.get()方法得到Future的处理结果，
 * 但是这个方法是阻塞的，因此并不利于我们开发高并发应用程序。
 * 在Guava中，增强了Future模式，增加了对Future完成时的回调接口，
 * 使得Future执行完成时可以自动通知应用程序进行后续处理
 */

public class Futurelistener {
    private ListenableFuture<String> future;

    public static void main(String[] args) throws InterruptedException {
        //zsg 这里和之前比就是ListeningExecutorService帮你在内部包装好了,返回一个开始执行了的ListenableFuture
        //而之前是自己手动创建一个FutureTask 包裹任务 然后交给线程执行
        //MoreExecutors.listeningDecorator()方法将一个普通的线程池包装为一个包含通知功能的Future线程池
        //这样和 在方法里传入对象参数,在方法体中操作线程,完成后回调 很像.但是这个会阻塞主线程么？ 不会
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
        ListenableFuture<String> futureTask = service.submit(new RealData("x"));
        futureTask.addListener(new Runnable() {
            @Override
            public void run() {
                System.out.println("异步处理成功:");

                try {
                    System.out.println(futureTask.get());
                } catch (ExecutionException | InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },MoreExecutors.directExecutor());

        System.out.println("main task done...");
        Thread.sleep(3000);
    }
}


    //zsg 添加guava依赖
    compile group: 'com.google.guava', name: 'guava', version: '20.0'

package com.android.arthogritybrary;

import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;

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

public class Futurelistener1 {
    private ListenableFuture<String> future;

    public static void main(String[] args) throws InterruptedException {
        //增加了对异常的处理
        ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
        ListenableFuture<String> futureTask = service.submit(new RealData("y"));

        Futures.addCallback(futureTask, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("异步处理成功,result = "+result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println("异步处理失败,e = "+t);
            }
        },MoreExecutors.newDirectExecutorService());

        System.out.println("main task done...");
        Thread.sleep(3000);
    }
}

三、增强的Future：CompletableFuture

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

/**
 * CompletableFuture和Future一样，可以作为函数调用的契约。
 * 向CompletableFuture请求一个数据，如果数据还没有准备好，请求线程就会等待。
 * 让人惊喜的是，我们可以手动设置CompletableFuture的完成状态
 */

public class AskThread implements Runnable {

    CompletableFuture<Integer> re = null;

    public AskThread(CompletableFuture<Integer> re) {
        this.re = re;
    }

    @Override
    public void run() {
        int myRe = 0;
        try {
            myRe = re.get() * re.get();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(myRe);
    }

    public static void main(String[] args) {
        CompletableFuture<Integer> completableFuture = new CompletableFuture<>();
        new Thread (new AskThread(completableFuture)).start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //可以手动告知完成状态
        completableFuture.complete(60);
    }
}

四、异步执行任务

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.Supplier;

public class AsyncCompletableF {


    public static Integer calc(Integer para) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return para * para;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //zsg 在supplyAsync()方法中，它会在一个新的线程中，执行传入的参数
        //supplyAsync()方法会立即返回，它返回的CompletableFuture对象实例就可以作为这次调用的契约

        //zsg 这里就是在里面封装了一个异步线程，这样就不用自己去创建线程执行了
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(new Supplier<Integer>() {
            @Override
            public Integer get() {
                return calc(50);
            }
        });
        System.out.println(completableFuture.get());
    }
}

五、流式调用

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletionStageStream {

    public static Integer calc(Integer para) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return para * para;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //CompletionStage流式API调用
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> calc(50))
                .thenApply((i) -> Integer.toString(i))
                .thenApply((str) -> "\"" + str + "\"")
                .thenAccept(System.out::println);

        //目的是等待calc()方法执行完成
        completableFuture.get();


    }
}

六、CompletableFuture中的异常处理

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureE {

    public static Integer calc(Integer para) {
        return para / 0;
    }


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> calc(50))
                //zsg
                .exceptionally(ex -> {
                    System.out.println(ex.toString());
                    return 0;
                }).thenApply((i) -> Integer.toString(i))
                .thenApply((str) -> "\"" + str + "\"")
                .thenAccept(System.out::println);

        completableFuture.get();
    }
}

七、组合多个CompletableFuture

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class MutiCompletableF {
    public static Integer calc(Integer para) {
        return para / 2;
    }
    //zsg 可以理解为一个串行,一个并行

/*    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> calc(50))
                //zsg
                .thenCompose((i) -> CompletableFuture.supplyAsync(() -> calc(i)))
                .thenApply((str) -> "\"" + str + "\"")
                .thenAccept(System.out::println);

        completableFuture.get();
    }*/

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> calc(50));
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> calc(25));

        //zsg
        CompletableFuture<Void> future = completableFuture.thenCombine(completableFuture2, (i, j) -> (i + j))
                .thenApply((str) -> "\"" + str + "\"")
                .thenAccept(System.out::println);
        future.get();
    }
}

八、支持timeout的CompletableFuture

package com.android.arthogritybrary;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class CompletableFutureT {

    public static Integer calc(Integer para) {
        return para / 2;
    }

    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return calc(50);
            //zsg orTimeout 和 compileSdkVersion  有关 31以上
        }).orTimeout(1, TimeUnit.SECONDS).exceptionally(e -> {
            System.out.println(e);
            return 0;
        }).thenAccept(System.out::println);

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
被揍的皮卡丘
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dart Future 使用
weixin_44051815的博客
11-29 1973
Future Dart 的异步对象，类似于 Javascript 中的 Promise。 Future 表示一个异步操作返回的结果； Future 是一个泛型类； Future 实现异步的原因是通过 dart 的 event loop，这里不过多赘述。 基本使用 import 'package:http/http.dart' as http; Future getIp() { final url = 'https://httpbin.org/ip'; return http.get(url
future-0.18.3
01-16
future-0.18.3
C++ future
Cdreamfly的博客
03-02 5267
promise 空模板 非 void 特化，用于在线程间交流对象 void 特化，用于交流无状态事件 类模板 std::promise 提供存储值或异常的设施，之后通过 std::promise 对象所创建的 std::future 对象异步获得结果。注意 std::promise 只应当使用一次。 每个 promise 与共享状态关联，共享状态含有一些状态信息和可能仍未求值的结果，它求值为值（可能为 void ）或求值为异常。 promise 可以对共享状态做三件事： 使就绪： promise 存储
Future 用法详解
.
04-21 2300
Future 用法详解 前言 为什么出现Future机制 常见的两种创建线程的方式。一种是直接继承Thread，另外一种就是实现Runnable接口。 这两种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 从Java 1.5开始，就提供了Callable和Future，通过它们可以在任务执行完毕之后得到任务执行结果。 Future模式的核心思想是能够让主线程将原来需要同步等待的这段时间用来做其他的事情。 因为可以异步获得执行结果，所以不用一直同步等待去获得执行结果。 Future 用法详解 用法很
Future类型
阳宗德的博客
10-10 2014
Future是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果的接口。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。 它的接口定义如下： public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning); boolean ...
Future 与 FutureBuilder
唐僧的专栏
11-17 1044
什么是Future？ Future表示在接下来的某个时间的值或错误，借助Future我们可以在Flutter实现异步操作。 它类似于ES6中的Promise，提供then和catchError的链式调用； Future是dart:async包中的一个类，使用它时需要导入dart:async包，Future有两种状态： pending - 执行中； completed - 执行结束，分两种情况要么成功要么失败； Future的常见用法？ 使用future.then获取future的值与捕获fu
future-0.18.2-py3-none-any.whl 官网太难下载了
05-31
future-0.18.2-py3-none-any.whl 官网太难下载了
比较java中Future与FutureTask之间的关系
08-26
Future与FutureTask之间的关系 在Java中，Future和FutureTask都是用于获取线程执行的返回结果，但是它们之间存在一些差异和关联。本文将详细介绍Future和FutureTask的关系、使用和分析。 一、Future介绍 Future...
了解JAVA Future类
08-25
"了解JAVA Future类" Java Future类是一种并发编程中的一种设计模式，Future它代表一个异步计算的结果。Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 624
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 704
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
探讨 MyBatis 特殊 SQL 执行技巧与注意事项
良月柒
06-18 624
/MyBatis 作为一个灵活的持久层框架，通过提供丰富的动态 SQL 标签、SQL 片段复用、存储过程调用、复杂结果集处理、分页查询和批量操作等功能，使开发者能够高效地实现各种复杂的 SQL 操作。
SpringCloud Alibaba Sentinel基础入门与安装
小小默：进无止境
06-19 269
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式、多语言异构化服务架构的流量治理组件，主要以流量为切入点，从流量路由、流量控制、流量整形、熔断降级、系统自适应过载保护、热点流量防护等多个维度来帮助开发者保障微服务的稳定性。
Javase.认识异常
最新发布
Joseit的博客
06-21 1135
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 488
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 356
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
c# 学习笔记 PropertyChangedEventHandler、 =＞、DependencyObject、DataContext
汤圆
06-19 716
在C#中，和常常与接口一起使用，这是实现数据绑定和通知机制的关键部分，尤其在WPF (Windows Presentation Foundation) 或其他支持数据绑定的UI框架中。
c++ future
05-13
C++11 引入了 std::future 用于表示异步操作的结果。std::future 对象可以用来获取异步操作的结果或者等待异步操作的完成。 当我们需要执行一个耗时的操作时，如果在主线程中执行，会阻塞主线程导致用户无法进行其他操作，为了避免这种情况，我们可以使用 std::async 来创建一个异步任务，std::async 函数会立即返回一个 std::future 对象，可以通过该对象来获取异步任务的执行结果或者等待异步任务的完成。 例如，下面的代码展示了如何使用 std::async 创建一个异步任务并获取结果： ```cpp #include <iostream> #include <future> int main() { std::future<int> result = std::async([](){ // 模拟耗时操作 std::this_thread::sleep_for(std::chrono::seconds(2)); return 42; }); // 获取异步任务的结果 int res = result.get(); std::cout << "The result is " << res << std::endl; return 0; } ``` 上述代码中，通过 std::async 创建一个 lambda 表达式作为异步任务，该异步任务会休眠2秒钟后返回值 42。通过调用 std::future 的 get() 函数可以获取异步任务的结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值