【练习/Java并发】实现CompletableFuture简单版

已于 2023-08-30 14:46:09 修改
阅读量173 收藏 1
点赞数 5
文章标签： java 前端 servlet
于 2022-11-30 17:57:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uracil/article/details/128118813
版权

最近在学习过程中了解到了CompletableFuture异步编排，感觉很好用。（不过我还是更习惯使用传统方式控制多线程）
还没有看过源码，想试试能不能简单实现部分功能。如果你发现代码的问题希望指出。
暂时实现了supplyAsync() whenCompleteAsync() 和 exceptionally()。

1 实现

  1. 起名叫SimpleCompletableFuture
    public class SimpleCompletableFuture<T> implements Future {
	...
}
  2. 成员变量
    除了自己使用的锁等对象之外都要使用volatile保证异步线程对结果更新的可见性。
    // 保存自己的运算结果
private volatile T result;
// 保存异常
private volatile Throwable throwable;
// 任务完成标志
private volatile boolean done;
// 是否是异步任务
private volatile boolean async;
// 锁
private final Lock lock = new ReentrantLock();
// 条件变量
private final Condition condition = lock.newCondition();
// 整个类共用一个线程池来执行
private final static ExecutorService pool = Executors.newFixedThreadPool(10);
  3. supplyAsync方法
    这是一个静态方法，可以作为异步编排的开始，得到一个SimpleCompletableFuture对象。
    public static <U> SimpleCompletableFuture<U> supplyAsync(Supplier<U> supplier) {
    SimpleCompletableFuture<U> future = new SimpleCompletableFuture<>();
    future.async = true;
    pool.submit(() -> {
        // 开启线程异步执行
        try {
            future.result = supplier.get();
        } catch (Throwable thr) {
            future.throwable = thr;
        } finally {
            future.done = true;
            // 通知所有等待自己完成的线程
            notifyAllOnCondition(future);
        }
    });
    return future;
}

private static void notifyAllOnCondition(SimpleCompletableFuture<?> future) {
    future.lock.lock();
    try {
        future.condition.signalAll();
    } finally {
        future.lock.unlock();
    }
}
  4. whenCompleteAsync方法
    public SimpleCompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
    SimpleCompletableFuture<T> nextFuture = copyUndone();
    pool.submit(() -> {
        waitForDone();
        nextFuture.result = this.result;
        nextFuture.throwable = this.throwable;
        // 任务已经完成了
        action.accept(this.result, this.throwable);
        // 设置完成标志位，通知等待线程
        finishWork(nextFuture);
    });
    nextFuture.async = true;
    return nextFuture;
}

// 就是用来复制一个this但是完成标志为false
private SimpleCompletableFuture<T> copyUndone() {
   SimpleCompletableFuture<T> newFuture = new SimpleCompletableFuture<>();
    newFuture.result = this.result;
    newFuture.throwable = this.throwable;
    newFuture.async = this.async;
    newFuture.done = false;
    return newFuture;
}

private void waitForDone() {
    lock.lock();
    try {
        while (!done) {
            try {
                condition.await();
            } catch (InterruptedException ignored) {
            }
        }
    } finally {
        lock.unlock();
    }
}

private void finishWork(SimpleCompletableFuture<?> future) {
    future.done = true;
    notifyAllOnCondition(future);
}
  5. exceptionally方法
    public SimpleCompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {
    if (async) {
        SimpleCompletableFuture<T> nextFuture = copyUndone();
        pool.submit(() -> {
            waitForDone();
            if (this.throwable != null) {
                nextFuture.result = fn.apply(throwable);
            }
            finishWork(nextFuture);
        });
        return nextFuture;
    } else {
        waitForDone();
        if (this.throwable != null) {
            this.result = fn.apply(throwable);
        }
        return this;
    }
}
  6. get方法
    @Override
public T get() {
    waitForDone();
    return this.result;
}

2 测试

class Test {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");
        SimpleCompletableFuture<Integer> future = SimpleCompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int a = 1 / 0;
            return a;
        }).whenCompleteAsync((result, exception) -> {
            System.out.println(sdf.format(new Date()) + " --- " + exception.getClass().getName());
        }).exceptionally(exception -> {
            return 1;
        });
        System.out.println(sdf.format(new Date()) + " --- main at 32");
        System.out.println("get: " + future.get());
    }
}

输出

52:32 --- main at 32
52:34 --- java.lang.ArithmeticException
get: 1

3 完整代码

package completable;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.BiConsumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author dujianzhang
 */
class Test {
    public static void main(String[] args) {
        SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");
        SimpleCompletableFuture<Integer> future = SimpleCompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int a = 1 / 0;
            return a;
        }).whenCompleteAsync((result, exception) -> {
            System.out.println(sdf.format(new Date()) + " --- " + exception.getClass().getName());
        }).exceptionally(exception -> {
            return 1;
        });
        System.out.println(sdf.format(new Date()) + " --- main at 32");
        System.out.println("get: " + future.get());
    }
}

public class SimpleCompletableFuture<T> implements Future {

    private volatile T result;
    private volatile Throwable throwable;
    private volatile boolean done;
    private volatile boolean async;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final static ExecutorService pool = Executors.newFixedThreadPool(10);

    public static <U> SimpleCompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        SimpleCompletableFuture<U> future = new SimpleCompletableFuture<>();
        future.async = true;
        pool.submit(() -> {
            // 开启线程异步执行
            try {
                future.result = supplier.get();
            } catch (Throwable thr) {
                future.throwable = thr;
            } finally {
                future.done = true;
                notifyAllOnCondition(future);
            }
        });
        return future;
    }

    public SimpleCompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
        SimpleCompletableFuture<T> nextFuture = copyUndone();
        pool.submit(() -> {
            waitForDone();
            nextFuture.result = this.result;
            nextFuture.throwable = this.throwable;
            // 任务已经完成了
            action.accept(this.result, this.throwable);
            finishWork(nextFuture);
        });
        nextFuture.async = true;
        return nextFuture;
    }

    public SimpleCompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {
        if (async) {
            SimpleCompletableFuture<T> nextFuture = copyUndone();
            pool.submit(() -> {
                waitForDone();
                if (this.throwable != null) {
                    nextFuture.result = fn.apply(throwable);
                }
                finishWork(nextFuture);
            });
            return nextFuture;
        } else {
            waitForDone();
            if (this.throwable != null) {
                this.result = fn.apply(throwable);
            }
            return this;
        }
    }

    @Override
    public boolean cancel(boolean mayInterruptIfRunning) {
        // TODO
        return false;
    }

    @Override
    public boolean isCancelled() {
        // TODO
        return false;
    }

    @Override
    public boolean isDone() {
        return done;
    }

    @Override
    public T get() {
        waitForDone();
        return this.result;
    }

    @Override
    public Object get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        // TODO
        return null;
    }

    private void waitForDone() {
        lock.lock();
        try {
            while (!done) {
                try {
                    condition.await();
                } catch (InterruptedException ignored) {
                }
            }
        } finally {
            lock.unlock();
        }
    }

    private static void notifyAllOnCondition(SimpleCompletableFuture<?> future) {
        future.lock.lock();
        try {
            future.condition.signalAll();
        } finally {
            future.lock.unlock();
        }
    }

    private void finishWork(SimpleCompletableFuture<?> future) {
        future.done = true;
        notifyAllOnCondition(future);
    }

    private SimpleCompletableFuture<T> copyUndone() {
        SimpleCompletableFuture<T> newFuture = new SimpleCompletableFuture<>();
        newFuture.result = this.result;
        newFuture.throwable = this.throwable;
        newFuture.async = this.async;
        newFuture.done = false;
        return newFuture;
    }

}
丑橘u
关注
【第81题】JAVA高级技术-多线程15（CompletableFuture实战)
小虚竹的专栏
06-10 3万+
CompletableFuture实战
JUC并发编程第三篇，CompletableFuture场景练习，电商比价需求性能提升
I wanna be myself, where I Belong.
11-23 452
如果现在有一些网站物品价格初始数据串，我们想要进行比价，可以将这些数据保存到Redis的Zset里边，保证数据没有重复，然后进行比较，第一种笨办法就是一条数据一条数据的过，但是这样性能不高；第二种，在JUC里边，有一个 CompletableFuture，用他做多线程异步并发是不阻塞的，而且可以自定义线程池，线程池根据数据量的大小伸缩，在数据量变大时仍能保证效率，大大提升程序性能。案例说明：电商比价需求。
Day843.CompletableFuture -Java 并发编程实战
阿昌爱Java
12-29 491
回调地狱应该说在前些年，异步编程还是声名狼藉的。不过最近几年，伴随着ReactiveX的发展（Java 语言的实现版本是 RxJava），回调地狱已经被完美解决了，异步编程已经慢慢开始成熟，Java 语言也开始官方支持异步编程：在 1.8 版本提供了 CompletableFuture，在 Java 9 版本则提供了更加完备的 Flow API，异步编程目前已经完全工业化。因此，学好异步编程还是很有必要的。
Java8新特性-CompletableFuture-实战(二)
wbb9019的博客
09-06 331
CompletableFuture重构我的业务代码 描述业务场景 根据一个手机号获取一批结果集合，业务需要时并发查询solr服务和rw服务,然后将rw的第一条结果取出来和solr的结果合并成一个list返回，同时solrServer服务返回结果的时候,还需要根据结果去调用tag服务和pic服务丰富数据 延迟模拟和期望返回时间 solrServer延迟1s rwServer延迟5s t...
《Java8实战》第11章 CompletableFuture：组合式异步编程（一）
火柴头的专栏
11-05 299
11.1 Future接口 Future接口的一般用法 假设某业务逻辑有三个“计算”逻辑： 购买煎饼果子（要等待好久）； 购买已装杯的豆浆（很快）； 乘班车上班（绝对不能错过）。 同步编程就是： 购买煎饼果子； 完成步骤1后，再购买已装杯的豆浆； 完成步骤2后，再乘班车上班。 假设步骤1的时间不定，而班车发车时间是固定的，那极有可能错过班车。 异步编程就是： 给老板说一声购买煎饼果子，稍...
JAVA高质量并发详解,多线程并发深入讲解
最新发布
04-24
#### 一、Java并发编程基础 - **基础知识：** - **线程基本概念：** Java线程是程序执行流的最小单元，一个线程包含一个程序计数器(PC)、虚拟机栈、本地方法栈、线程私有的工作内存。 - **线程生命周期：** 包括`...
java并发.rar
04-06
综上所述，"java并发.rar"的课程资料可能会涵盖这些内容，并通过实例和练习帮助学习者深入理解和掌握Java并发编程的原理与实践。通过系统地学习和实践，开发者可以提高其在多线程环境下的编程能力，解决复杂并发问题...
Java多线程与并发库视频资源网盘链接
04-11
4. **并发库（java.util.concurrent）**：Java并发库提供了强大的工具，如Executor框架、Future、Callable接口以及并发容器（如ConcurrentHashMap、CopyOnWriteArrayList等）。这些工具能够帮助开发者更高效地管理...
Java并发编程实践
02-21
根据提供的文件信息，我们可以深入探讨...通过这些实践案例的学习和练习，可以极大地提升开发者对Java并发编程的理解和实际操作能力。希望以上总结能够对你有所帮助，如果你有任何疑问或想要了解更多细节，请随时提问。
计算机后端-Java-Java高并发从入门到面试教程-可.zip
05-21
Java高并发编程是Java开发中的重要领域，尤其在大型互联网应用和企业级系统中，对高并发处理能力的要求非常高。本教程将引导你从零基础开始，逐步掌握Java并发...不断练习和总结，你将成为一名出色的Java并发编程专家。
《Java8 实战》笔记——4.CompletableFuture-组合式异步编程
娜娜米的博客
03-22 1442
第 11 章 completableFuture组合式异步编程 Future/Callable Future接口可以构建异步应用，是多线程开发中常见的设计模式； 当我们需要调用一个函数方法时，如果这个函数执行很慢，那么我们就要进行等待；但有时候，我们可能并不急着要结果；因此，我们可以让被调用者立即返回，让他在后台慢慢处理这个请求；对于调用者来说，则可以先处理一些其他任务，在真正需要数据的场合再去尝试获取需要的数据（或者回调）； （图） sync模式 & async模式 区别
异步编程利器：CompletableFuture详解 ｜Java 开发实战
pengjianglilive的专栏
11-08 495
我们异步执行一个任务时，一般是用线程池Executor去创建。如果不需要有返回值， 任务实现Runnable接口；如果需要有返回值，任务实现Callable接口，调用Executor的submit方法，再使用Future获取即可。如果多个线程存在依赖组合的话，我们怎么处理呢？可使用同步组件CountDownLatch、CyclicBarrier等，但是比较麻烦。其实有简单的方法，就是用CompeletableFuture。最近刚好使用CompeletableFuture优化了项目中的代码，所以跟大家一起学习
「并发编程专题」教你如何使用异步神器CompletableFuture
西八老码
08-05 200
前提概要 在java8以前，我们使用java的多线程编程,一般是通过Runnable中的run方法来完成,这种方式，有个很明显的缺点,就是，没有返回值。这时候，大家可能会去尝试使用Callable中的call方法，然后用Future返回结果，如下: public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor();
编程老司机带你玩转 CompletableFuture 异步编程
楼下小黑哥
03-09 1202
本文从实例出发，介绍 CompletableFuture 基本用法。不过讲的再多，不如亲自上手练习一下。所以建议各位小伙伴看完，上机练习一把，快速掌握 CompletableFuture。 个人博文地址：https://sourl.cn/s5MbCm 全文摘要： Future VS CompletableFuture CompletableFuture 基本用法 0x00. 前言 一些业务...
java多线程与并发原理学习笔记（七）java8异步神器CompletableFuture
飞！！！的博客
05-09 1212
是java8提供的一个异步编程类，提供了一系列的异步编程方法。它同时实现了Future和接口。所以不但包含了Future的功能特性，而且还实现了接口定义的任务编排的方法，可以实现不同任务的运行顺序、规则以及方式。
CompletableFuture 异步编程
小强快跑~~
06-09 478
本文从实例出发，介绍CompletableFuture基本用法。不过讲的再多，不如亲自上手练习一下。所以建议各位小伙伴看完，上机练习一把，快速掌握CompletableFuture。 全文摘要： FutureVSCompletableFuture CompletableFuture基本用法 0x00. 前言 一些业务场景我们需要使用多线程异步执行任务，加快任务执行速度。Java 提供RunnableFuture<V>两个接口用来实现异步任务逻辑。 虽然...
20个实例玩转 Java 8 异步神器 CompletableFuture，你真的会用吗？
码猿技术专栏
09-25 312
点击上方☝码猿技术专栏轻松关注，设为星标！及时获取有趣有料的技术前言在Java中异步编程，不一定非要使用rxJava, Java本身的库中的CompletableFuture可以很好的应...
Java并发编程——CompletableFuture类
Hopefully Sky的博客
07-27 4153
从Future接口开始 java.util.concurrent.Future接口是Java 5添加的类，用来描述一个异步计算的结果。可以使用该接口的isDone()方法检查计算是否完成，或者使用get()阻塞住调用线程，直到计算完成返回结果，也可以使用cancel()方法停止任务的执行。 ExecutorService es = Executors.newFixedThreadPool(10); Future<Integer> f = es.submit(() ->{ /
并发编程：浅谈CompletionService 和 CompletableFuture （附高德笔试题）
weixin_44735065的博客
04-13 1517
并发编程：浅谈CompletionService 和 CompletableFuture 目录并发编程：浅谈CompletionService 和 CompletableFuture一、CompletionService1. 原理2.应用场景3.使用案例案例一：向不同电商平台询价，并保存案例二：并行地调用多个服务，只要有一个成功就返回结果二、CompletableFuture1.应用场景a.依赖关系b.聚合关系（and）c.聚合关系（or）d.并行执行2.详解a.创建异步操作b.结果处理c.结果转换d.结果
Java并发编程实战：第二版高清解读
"Mastering Concurrency Programming...通过本书，读者不仅可以提升对Java并发编程的理解，还能获得在实际项目中有效利用并发能力的技能。对于任何想要在Java平台上构建高效、可扩展系统的人来说，这是一本宝贵的资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值