【JUC基础】15. Future模式

这篇具有很好参考价值的文章主要介绍了【JUC基础】15. Future模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

1、前言

2、什么是Future

2.1、传统程序调用

3、JDK中的Future

3.1、Future相关API

3.2、FutureTask

3.2.1、FutureTask实现

3.2.2、FutureTask相关API

3.3、CompletableFuture

3.3.1、thenApply

3.3.2、异步任务编排之thenCompose()

3.3.3、异步任务编排之thenCombine()

3.3.4、异步任务编排之allOf()

3.3.5、异常处理

4、小结


1、前言

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

2、什么是Future

大白话理解就是,Future 模式有点类似在网上买东西。如果我们在网上下单买了一部手机,当我们支付完成后,手机并没有办法立即送到家里,但是在电脑上会立即产生一个订单。这个订单就是将来发货或者领取手机的重要凭证,这个凭证也就是 Future 模式中会给出的一个契约。在支付活动结束后,大家不会傻傻地等着手机到来,而是各忙各的。而这张订单就成了商家配货、发货的驱动力。

对于Future模式来说,他虽然无法给出你需要的数据,但是他会返回一个契约给你,将来你可以凭借这个契约去重新获取你需要的信息。

而java.util.concurrent.Future是一个接口,是用于表示异步计算结果的抽象。它代表了一个可能在未来完成的计算,可以用于获取计算结果、取消计算、查询计算是否完成等操作。Java 5引入的Future接口为异步编程提供了方便的抽象,可以更好地处理并发和并行任务。

2.1、传统程序调用

【JUC基础】15. Future模式

传统的调用方式,当客户端发出call请求,需要等到call_01调用call_02,且call_02和call_01返回后,其他的任务才能执行(self call)。

2.2、Future模式调用

【JUC基础】15. Future模式

从上图可以看到,call_02时,数据本身需要很长一段时间来处理才能返回结果。但是,服务程序无需等待数据处理完成,便可以提前返回给客户端一个伪造的数据(相当上面提到的凭证,而不是数据本身)。实现了客户端拿到这个返回结果后,不用着急对其处理,而是可以先去完成其他的业务瑞吉(如self call),而无需阻塞等待call_02的执行结束。充分利用了等待时间。在完成了其他业务逻辑处理后,再去使用返回慢的Future数据。

3、JDK中的Future

前面说到Future模式的一个基本概念以及雏形,这个模式其实在项目中是很常用的。所以JDK内部已经为我们准备了一套完整的实现。那就是Future,Future是个接口,对具体的Runnable和Callable任务进行取消,查询获取结果,并会检索计算结果。get()获取任务结果,该任务是阻塞的。

【JUC基础】15. Future模式

 【JUC基础】15. Future模式

3.1、Future相关API

package java.util.concurrent;

public interface Future<V> {
    boolean cancel(boolean var1);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long var1, TimeUnit var3) throws InterruptedException, ExecutionException, TimeoutException;
}

【JUC基础】15. Future模式

举个简单的例子:

public static void main(String[] args) throws ExecutionException, InterruptedException {
    ExecutorService executorService = Executors.newFixedThreadPool(10);

    // 这里使用submit提交可以看到返回Future
    Future<String> submit = executorService.submit(() -> {
        System.out.println("child thread is deal......");
        ThreadUtil.sleep(1000);
        
        // 由于线程池submit是可以接收callable,因此可以直接返回。如果使用runnable,线程池可以支持submit(runnable, result),
        // 将需要线程返回的数据通过定义result传入
        return "child return result “hello future”";
    });
    System.out.println("main thread is deal......");
    ThreadUtil.sleep(1000);

    // 通过future.get()阻塞等待返回结果
    System.out.println("main thread  ->  " + submit.get());
}

执行结果:可以看到main thread结果打印,永远在child thread is deal......打印之后,证明get()是阻塞等待的。但是在等待的中间,我们是可以处理其他的任务的,比如打印的main thread is deal......

【JUC基础】15. Future模式

3.2、FutureTask

Future是个接口,而FutureTask就是他的其中一个实现。FutureTask实现了RunnableFuture接口,RunnableFuture接口又实现了Runnable接口和Future接口。所以FutureTask既可以被当做Runnable来执行,也可以被当做Future来获取Callable的返回结果。

3.2.1、FutureTask实现

从3.1的示例代码中,我们跟进去submit()方法,选择AbstractExecutorService实现。我们可以看到:

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

我们可以看到最终将callable封装进了FutureTask。而FutureTask真正执行的方法:

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                // 因为构造传入的callable,所以调用了callable的call方法
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            // 如果ran结束,则设置执行结果
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

而set(result)方法如下:

/**
 * Sets the result of this future to the given value unless
 * this future has already been set or has been cancelled.
 *
 * <p>This method is invoked internally by the {@link #run} method
 * upon successful completion of the computation.
 *
 * @param v the value
 */
protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        // 这里将结果设置到outcome中
        outcome = v;
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        finishCompletion();
    }
}

// 执行结束之后的操作
private void finishCompletion() {
    // assert state > COMPLETING;
    for (WaitNode q; (q = waiters) != null;) {
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            for (;;) {
                Thread t = q.thread;
                if (t != null) {
                    q.thread = null;
                    
                    // 通过unpark给当前线程一个许可凭证
                    LockSupport.unpark(t);
                }
                WaitNode next = q.next;
                if (next == null)
                    break;
                q.next = null; // unlink to help gc
                q = next;
            }
            break;
        }
    }

    done();

    callable = null;        // to reduce footprint
}

而当我们调用get()方法:

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        // 阻塞等待,默认0L表示永久等待
        s = awaitDone(false, 0L);
        
    // 这里获取
    return report(s);
}

private V report(int s) throws ExecutionException {
    // 这里获取到outcome
    Object x = outcome;
    if (s == NORMAL)
        return (V)x;
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

3.2.2、FutureTask相关API

【JUC基础】15. Future模式

3.3、CompletableFuture

前面说到FutureTask,实现了完整的Future模式。但是显然还有几个问题:

  1. Future提供了isDone()方法用来判断当前异步任务是否完成,不支持回调方法。而当你需要任务执行结束后就去做其他操作,就得不断的判断isDone()是否结束。
  2. 异步任务的编排。假如你有三个任务需要异步执行,而第三个任务需要前面两个任务结束后合并处理第三个,Future无法实现。
  3. Future并没有任何异常的处理。

为了解决这些问题,JDK在1.8的时候引入了CompletableFuture。CompletableFuture也是实现了Future的接口,对FutureTask进行了扩展。

【JUC基础】15. Future模式

CompletableFuture很好的解决了上述的问题:

  1. CompletableFuture提供了thenApply,thenApplyAsync等方法,用于在任务执行结束后,可以传入进去一个回调方法。
  2. CompletableFuture提供了更灵活的方式来编排多个并发任务的执行顺序和依赖关系。通过使用thenCompose()、thenCombine()、allOf()等方法,可以更方便地实现并发任务的调度和控制。
  3. CompletableFuture提供了exceptionally()方法和handle()方法来处理异步任务执行过程中的异常情况。可以通过这些方法对异常进行处理,并返回一个默认值或执行备选操作。

3.3.1、thenApply

当使用CompletableFuture时,可以使用thenApply()方法来对异步任务的结果进行处理。thenApply()方法接受一个Function函数式接口作为参数,用于对前一个任务的结果进行转换或处理,并返回一个新的CompletableFuture对象,表示转换后的结果。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    // 支持链式语法
    .thenApply(result -> result + " CompletableFuture!")
    .thenApply(result -> result.toUpperCase());

future.thenAccept(System.out::println); // 输出:HELLO COMPLETABLEFUTURE!

3.3.2、异步任务编排之thenCompose()

任务2需要任务1的结果,进行合并计算。

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "CompletableFuture!");

CompletableFuture<String> combinedFuture = future1.thenCompose(result1 ->
    future2.thenApply(result2 -> result1 + " " + result2)
);

combinedFuture.thenAccept(System.out::println); // 输出:Hello CompletableFuture!

在这个示例中,我们创建了两个独立的异步任务 future1 和 future2。然后使用 thenCompose() 方法,将第二个任务 future2 的结果与第一个任务 future1 的结果进行组合,并返回一个新的 CompletableFuture 对象 combinedFuture。最后,我们通过调用 thenAccept() 方法来接收并输出组合后的结果。

3.3.3、异步任务编排之thenCombine()

任务1和任务2的结果进行合并处理。

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "CompletableFuture!");

CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + " " + result2);

combinedFuture.thenAccept(System.out::println); // 输出:Hello CompletableFuture!

在这个示例中,我们仍然有两个独立的异步任务 future1 和 future2,但是这次我们使用了 thenCombine() 方法,它接受两个 CompletableFuture 对象和一个 BiFunction 函数式接口作为参数,用于组合两个任务的结果。在示例中,我们使用 lambda 表达式将两个结果进行连接并返回。

3.3.4、异步任务编排之allOf()

等待任务1和任务2完成后,调用回调方法。

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "CompletableFuture!");

CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);

allFutures.thenRun(() -> {
    String result1 = future1.join();
    String result2 = future2.join();
    System.out.println(result1 + " " + result2);
});

在这个示例中,我们有两个独立的异步任务 future1 和 future2,并使用 CompletableFuture.allOf() 方法来等待它们都完成。然后,我们使用 thenRun() 方法定义一个任务,当所有的任务完成后执行其中的代码块。在代码块中,我们使用 join() 方法来获取每个任务的结果,并将它们连接在一起输出。

3.3.5、异常处理

当使用CompletableFuture时,可以使用exceptionally()方法和handle()方法来处理异步任务执行过程中的异常情况。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟一个可能会抛出异常的异步任务
    if (Math.random() < 0.5) {
        throw new RuntimeException("Oops, something went wrong!");
    }
    return 42;
});

CompletableFuture<Integer> handledFuture = future.exceptionally(ex -> {
    System.out.println("Exception occurred: " + ex.getMessage());
    return 0; // 提供一个默认值来替代异常情况下的结果
});

handledFuture.thenAccept(result -> System.out.println("Result: " + result));

在这个示例中,我们使用CompletableFuture.supplyAsync()方法创建了一个异步任务,它可能会抛出一个运行时异常。然后,我们通过调用exceptionally()方法,传入一个函数式接口来处理异常情况。在异常发生时,exceptionally()方法会执行传入的函数,并返回一个新的CompletableFuture对象,该对象包含了处理异常后的结果(在这个例子中,我们返回了一个默认值 0)。最后,我们通过调用thenAccept()方法来接收并输出最终的结果。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 模拟一个可能会抛出异常的异步任务
    if (Math.random() < 0.5) {
        throw new RuntimeException("Oops, something went wrong!");
    }
    return 42;
});

CompletableFuture<Integer> handledFuture = future.handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Exception occurred: " + ex.getMessage());
        return 0; // 提供一个默认值来替代异常情况下的结果
    }
    return result;
});

handledFuture.thenAccept(result -> System.out.println("Result: " + result));

在这个示例中,我们也是创建了一个可能会抛出异常的异步任务,并使用CompletableFuture.supplyAsync()方法进行包装。然后,通过调用handle()方法,传入一个BiFunction函数式接口来处理结果和异常。handle()方法会在任务执行完成后执行传入的函数,无论是否发生异常。在函数中,我们可以根据异常情况来处理结果,这里我们在发生异常时返回了一个默认值 0。最后,我们通过调用thenAccept()方法来接收并输出最终的结果。

exceptionally()方法主要用于处理异步任务执行过程中的异常,提供一个备选的结果或处理逻辑。它只处理异常,不会对正常的结果进行额外的处理。

handle()方法用于处理异步任务执行过程中的结果和异常,可以在一个方法内部同时处理结果和异常,并返回一个新的结果。它对异常和正常结果都进行处理,更加灵活。

4、小结

到这里Future模式以及JDK提供的实现都已经介绍的差不多了。Future模式是典型的ForkJoin思想,除了JDK提供的相关支持以外,不少的第三方库也实现了Future模式,有些提供了更加强大的实现,比如Guava等。这些为以后的并行处理提供了更加方便,更加强大,更加简化的编程模型。文章来源地址https://www.toymoban.com/news/detail-472824.html

到了这里,关于【JUC基础】15. Future模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JUC并发编程学习笔记(十七)彻底玩转单例模式

    单例中最重要的思想-------构造器私有! 恶汉式、懒汉式(DCL懒汉式!) 恶汉式 懒汉式 DCL懒汉式 完整的双重检测锁模式的单例、懒汉式、DCL懒汉式 但是有反射!只要有反射,任何的代码都不安全,任何的私有都是摆设 正常的单例模式: 反射破坏单例: 怎么去解决这

    2024年02月05日
    浏览(46)
  • 【JUC基础】14. ThreadLocal

    目录 1、前言 2、什么是ThreadLocal 3、ThreadLocal作用 4、ThradLocal基本使用 4.1、创建和初始化 4.2、存储和获取线程变量 4.3、清理和释放线程变量 4.4、小结 4.5、示例代码 5、ThreadLocal原理 5.1、set() 5.2、get() 5.3、变量清理 5.4、ThreadLocalMap 6、InheritableThreadLocal 一般提到多线程并发总是

    2024年02月07日
    浏览(39)
  • 【JUC基础】09. LockSupport

      LockSupport是一个线程阻塞工具,可以在线程任意位置让线程阻塞。线程操作阻塞的方式其实还有Thread.suspend()和Object.wait()。而LockSupport与suspend()相比,弥补了由于resume()方法而导致线程被挂起(类似死锁)的问题,也弥补了wait()需要先获得某个对象锁的问题,也不会抛出Inte

    2024年02月06日
    浏览(57)
  • 【JUC基础】04. Lock锁

    java.util.concurrent.locks为锁定和等待条件提供一个框架的接口和类,说白了就是锁所在的包。 Lock是一种锁机制,比同步块(synchronized block)更加灵活,同时也更加复杂的线程同步机制。在JDK1.5就已存在Lock接口了。 其中有三个实现类: ReentrantLock:可重入锁 ReentrantReadWriteLock.R

    2024年02月04日
    浏览(37)
  • 【JUC基础】08. 三大工具类

    JUC包中包含了三个非常实用的工具类:CountDownLatch(倒计数器),CyclicBarrier(循环栅栏),Semaphore(信号量)。 英文中Count Down意为倒计数,Latch意为门闩,所以简单称之为倒计数器。门闩的含义就是把门锁起来,不让里面的线程跑出来。因此这个工具通常用来控制线程等待。

    2024年02月07日
    浏览(28)
  • JUC 高并发编程基础篇

    • 1、什么是 JUC • 2、Lock 接口 • 3、线程间通信 • 4、集合的线程安全 • 5、多线程锁 • 6、Callable 接口 • 7、JUC 三大辅助类: CountDownLatch CyclicBarrier Semaphore • 8、读写锁: ReentrantReadWriteLock • 9、阻塞队列 • 10、ThreadPool 线程池 • 11、Fork/Join 框架 • 12、CompletableFuture 1 什么

    2024年02月07日
    浏览(53)
  • 【自制视频课程】C++OpnecV基础35讲——第一章 前言

            首先,opencv是一个广泛使用的计算机视觉库,它提供了丰富的图像处理和计算机视觉算法,可以帮助我们快速地开发出高质量的图像处理应用程序;         其次,opencv是一个开源库,可以免费使用和修改,这为我们提供了一个学习和研究计算机视觉的良好平

    2024年02月05日
    浏览(55)
  • 【JUC基础】10. Atomic原子类

    Atomic英译为原子的。原子结构通常称为不可分割的最小单位。而在JUC中,java.util.concurrent.atomic 包是 Java 并发库中的一个包,提供了原子操作的支持。它包含了一些原子类,用于在多线程环境下进行线程安全的原子操作。使用原子类可以避免使用锁和同步机制,从而减少了线程

    2024年02月06日
    浏览(40)
  • 【JUC基础】16. Fork Join

    “分而治之”一直是一个非常有效的处理大量数据的方法。著名的MapReduce也是采取了分而治之的思想。。简单地说,就是如果你要处理 1000 个数据,但是你并不具备处理 1000个数据的能力,那么你可以只处理其中的 10 个,然后分阶段处理 100 次,将 100 次的结进行合成,就是最

    2024年02月08日
    浏览(49)
  • 【JUC基础】11. 并发下的集合类

    目录  1、前言 2、并发下的ArrayList 2.1、传统方式 2.1.1、程序正常运行 2.1.2、程序异常 2.1.3、运行期望值不符 2.2、加锁 2.3、synchronizedList 2.4、CopyOnWriteArrayList 3、并发下的HashSet 3.1、CopyOnWriteArraySet 3.2、HashSet底层是什么? 4、并发下的HashMap 4.1、传统方式 4.2、ConcurrentHashMap 4.3、

    2024年02月07日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包