多线程Future设计模式+异步处理

最新推荐文章于 2024-07-21 10:57:03 发布
最新推荐文章于 2024-07-21 10:57:03 发布
阅读量355 收藏
点赞数
分类专栏： 1.多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ss123mlk/article/details/116231400
版权
本文介绍了如何在Java中实现异步发送邮件功能，以提高用户体验。通过线程和FutureData类，模拟thread-per-message模式，确保在处理订单后立即返回结果，同时异步发送邮件。进一步讨论了使用JUC（Java并发工具包）的FutureTask和CompletableFuture优化方案，以及它们如何简化代码和增强异步操作的感知。
摘要由CSDN通过智能技术生成

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

现实场景

想实现异步发送邮件的功能，比如说，在客户成功提交了一个订单时，程序需要发送邮件给管理员和客户，然后报告说订单提交成功。
如果不用异步方式，那么当邮件发送很耗时的时候，用户就要等很久才能看到成功提示，
因此我想，在保存了订单数据后，就用另一个线程来发送邮件，从而当前线程立即就可以向用户反馈订单提交成功的提示信息。
在这里插入图片描述
这个就像thread-per-message模式
只不过有了futuredata可以用来存储结果 仍然是主线程立即结束返回响应 新启线程异步做委托的任务 主线程利用空闲时间去做其他事 多线程资源利用率高

当需要使用的时候向futuredata取值

基础代码实现

在这里插入图片描述

host类 和之前模式一样 只不过多了一个返回结果

package Future;

public class Host {

    public Data request(final char c,final int times) {
        System.out.println(Thread.currentThread().getName() + "输入手机号--"+System.currentTimeMillis());

        final MyFutureData myFutureData = new MyFutureData();
        /**
         * 异步新启动一个线程 后台操作 host主线程不再等待 直接返回操作成功提示信息
         */
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "异步执行业务 BEGIN--"+System.currentTimeMillis());
                RealData realData = new RealData(c, times);
                myFutureData.setContent(realData);
                System.out.println(Thread.currentThread().getName() + "异步执行结束 END--"+System.currentTimeMillis());


            }
        }).start();
        System.out.println(Thread.currentThread().getName() + "操作成功--"+System.currentTimeMillis());

        return myFutureData;
    }

}


package Future;

/**
 * @author sqpstart
 * @create 2021-04-28 13:23
 */
public interface Data {
    public String  getContent();
}

future类 守护类 里面维护真正的realdata

package Future;

/**
 * @author sqpstart
 * @create 2021-04-28 13:23
 */
public class MyFutureData implements  Data {
    private   RealData realData;
    private volatile boolean read; //已经存过值了
    @Override
    public synchronized String getContent() {
      while(!read){
          try {
              System.out.println("业务还未进行完毕"+Thread.currentThread().getName()+"等待");
              wait();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
      return realData.getContent();
    }


    public synchronized void setContent(RealData realData) {
       if(read){
           return;
       }
        this.realData=realData;
        read=true;
        notifyAll();

    }
}

realdata类 构造函数就是业务逻辑处理的本身 生成该对象 调用构造函数 就已经赋值future结果了

package Future;

/**
 * @author sqpstart
 * @create 2021-04-28 13:23
 */
public class RealData implements  Data{

    private String content;
   //将异步的业务结果 在realdata的构造函数里就封装好了
    public RealData(char c, int times) {
        System.out.println(Thread.currentThread().getName()+"进行真正的业务处理并返回数据"+System.currentTimeMillis());
        char[] buffer=new char[times];
        for (int i = 0; i < times; i++) {
           buffer[i]=c;
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        content=new String(buffer);
    }

    @Override
    public String getContent() {
        System.out.println(Thread.currentThread().getName()+"来获取内容了");
        return content;
    }
}


package Future;

/**
 * @author sqpstart
 * @create 2021-04-28 13:45
 */
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Data a = host.request('A', 10);
        Data b = host.request('B', 15);
        Data c = host.request('C', 7);

        System.out.println("我们都收到了请求操作成功的 回复,资源利用主线程去做其他事了"+System.currentTimeMillis());

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

        System.out.println("主线程回来取数据了"+System.currentTimeMillis());
        System.out.println(a.getContent()+"，"+b.getContent()+"，"+c.getContent());


    }
}

JUC代码实现

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
以前host显示的将realdata set进future里 现在这里是call（）方法返回值 会放到futuretask的set里

在这里插入图片描述

public class HostJUC {
    public FutureDataJUC request(final int count, final char c) {
        //向构造函数传递callable接口 并制定泛型 声明业务
        FutureDataJUC futureDataJUC = new FutureDataJUC(new Callable<RealData>() {
            @Override
            public RealData call() throws Exception {
                return new RealData(c, count);//只是生成对象 还没有执行业务
                //等下面线程调用起来才执行
            }
        });
        //线程启动
        new Thread(futureDataJUC).start();
        return futureDataJUC;
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

futureData继承futureTask< T> 构造函数中参数为callable
HOST在调用Futuredata完成setRealData的工作已经由父类futureTask 将callable的返回结果set来代替了
futuredata只需提供给客户端一个getCOntent的功能 并且其中也不再维护私有的realdata对象和守护模式等多线程操作 而是使用futuretask提供的get()获取Callable返回的realdata进行返回
callable里面维护了真正的核心业务 并且对之前拿一长串new Thread(){…}做了封装

在这里插入图片描述
在这里插入图片描述
其实也可以直接使用futuretask 操作 上面的示例 用futureData继承futureTask做了一个封装 其实可以省掉这一层封装 直接在HOST这个操作类调用task

futureData 唯一不同就是封装了getContent 函数 而如果直接用futureTask在客户端直接做了

public class Client {
    public static void main(String[] args) {
        //Host host = new Host();
        HostJUC host=new HostJUC();
       /* Data a = host.request('A', 10);
        Data b = host.request('B', 15);
        Data c = host.request('C', 7);*/

        FutureTask<RealData> a = host.request('A', 10);
        FutureTask<RealData> b = host.request('B', 15);
        FutureTask<RealData> c = host.request('C', 7);

        System.out.println("我们都收到了请求操作成功的 回复,资源利用主线程去做其他事了"+System.currentTimeMillis());

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

        System.out.println("主线程回来取数据了"+System.currentTimeMillis());
       // System.out.println(a.getContent()+"，"+b.getContent()+"，"+c.getContent());

        try {
            System.out.println(a.get().getContent()+"，"+b.get().getContent()+"，"+c.get().getContent());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


    }

package Future;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @author sqpstart
 * @create 2021-04-28 15:39
 */
public class HostJUC {
 /*   *//*   public futureTaskrequest(final int count, final char c) {
           //向构造函数传递callable接口 并制定泛型 声明业务
           futureTaskfutureTask= new FutureDataJUC(
            new Callable<RealData>() {
               @Override
               public RealData call() throws Exception {
                   return new RealData(c, count);//并没有生成对象
                   //等下面线程调用起来才声明
               }
           });
           //线程启动
           new Thread(futureDataJUC).start();
           return futureDataJUC;
       }*/
    public FutureTask<RealData> request( final char c,final int count) {
        //向构造函数传递callable接口 并制定泛型 声明业务
        FutureTask futureTask = new FutureTask(
                new Callable<RealData>() {
                    @Override
                    public RealData call() throws Exception {
                        return new RealData(c, count);//并没有生成对象
                        //等下面线程调用起来才声明
                    }
                });
        //线程启动
        new Thread(futureTask).start();
        return futureTask;
    }
}

Completable

package Future;

import java.util.concurrent.CompletableFuture;

/**
 * @author sqpstart
 * @create 2021-04-28 22:11
 */
public class MyCompletableFuture {
    public static void main(String[] args) throws InterruptedException {
        CompletableFutureHost host=new CompletableFutureHost();
        CompletableFuture<String> a = host.request('A', 10);
        CompletableFuture<String> b = host.request('B', 15);
        CompletableFuture<String> c = host.request('C', 7);

        Thread.sleep(1000);

        System.out.println(a.join()+b.join()+c.join());

    }
}
class CompletableFutureHost{

  public CompletableFuture request(final char c, final int count){
      CompletableFuture<String> async = CompletableFuture.supplyAsync(() -> {

          return new RealData(c, count).getContent();
      });
    return async;
  }
}

在这里插入图片描述
在这里插入图片描述
感知异步的结果以及异步操作是否发生异常
在这里插入图片描述

public static  void huidiao(){
        System.out.println(Thread.currentThread().getName()+"  开始         "+System.currentTimeMillis());

        CompletableFuture<Integer> future=CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"    "+System.currentTimeMillis());
            int i=10/2;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return i ;
        }).whenComplete((t,u)->{
            System.out.println("异步执行结束，回调结果和异常");
            System.out.println(Thread.currentThread().getName()+"    "+System.currentTimeMillis());
            System.out.println(t+"   "+u);
        });

        System.out.println(Thread.currentThread().getName()+future.join());
        System.out.println(Thread.currentThread().getName()+"  结束     "+System.currentTimeMillis());

    }

在这里插入图片描述
在这里插入图片描述
对异步结果和操作异常的处理
在这里插入图片描述
在这里插入图片描述
注意返回的泛型 thenApply会有返回结果 所以泛型是U
其余的没有返回结果 泛型是void

多线程异步实战

在这里插入图片描述

在这里插入图片描述
上面这个类会自动注入容器 然后找到下图配置文件中与gulimall.thread为前缀的配置
在这里插入图片描述
直接在线程池配置类中引入刚才的properties 并且把自己配置的线程池@BEAN 注入到容器里 搭配completablefuture就用了

因为线程池不会根据业务结束就销毁线程 而是一直让线程活着 节省销毁的时间
而且新任务来了 也不用等待 创建线程去应对 而是直接执行 节省时间 资源

在这里插入图片描述

自动注入 我们给容器中放入的线程池
在这里插入图片描述

在这里插入图片描述

多学就会融会贯通
关注
专栏目录
奇淫巧技，CompletableFuture 异步多线程是真的优雅
weixin_57907028的博客
08-16 3255
CompletableFuture的get()方法是阻塞的，我们一般建议使用future.get(5, TimeUnit.SECONDS)。并且一般建议使用自定义线程池。但是如果线程池拒绝策略是DiscardPolicy或者DiscardOldestPolicy，当线程池饱和时，会直接丢弃任务，不会抛弃异常。因此建议，CompletableFuture线程池策略最好使用AbortPolicy，然后耗时的异步线程，做好线程池隔离哈。...
C#综合揭秘——细说多线程（上）
weixin_33859231的博客
02-07 354
引言 本文主要从线程的基础用法，CLR线程池当中工作者线程与I/O线程的开发，并行操作PLINQ等多个方面介绍多线程的开发。其中委托的BeginInvoke方法以及回调函数最为常用。而 I/O线程可能容易遭到大家的忽略，其实在开发多线程系统，更应该多留意I/O线程的操作。特别是在ASP.NET开发当中，可能更多人只会留意在客户端使用Ajax或者在服务器端使用UpdatePanel。其...
【JAVA多线程】Future，专为异步编程而生
最新发布
Joker_ZJN的博客
07-21 1642
十分钟，快速入门java future体系。
Java多线程编程-（19）-多线程异步调用之Future模式
liuxinyang666的博客
11-27 227
一、线程计数器回顾 在《Java多线程编程-（8）-两种常用的线程计数器CountDownLatch和循环屏障CyclicBarrier》 这一篇中，我们使用线程计数器的方式实现了在主线程中等待计数的线程执行完之后在执行阻塞等待之后的代码。看段代码回顾一下：这里简单的回顾了一下CountDownLatch，这是因为CountDownLatch也实现了类似异步调用的过程，只不过具体的任务由线程去执行
future 线程异步操作
weixin_42951026的博客
10-21 329
future线程
项目中- 多线程异步 Future 使用
Mynah886的博客
06-28 1011
一. 项目中架构要求： 外围客户端系统 - 交易中心微服务(场景微服务) - 交易集市微服务/能力中心 - ESB - 后方系统(理财/基金等)。 交易中心需要同时调用交易集市十几个组件/接口。由于通讯时间太长和接口请求太多，考虑使用多线程。 考虑使用非阻塞的多线程类 Future。Future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。 二. 项目使用是银行内部代码，不便于展示，当时的案例...
Java多线程之异步Future机制的原理和实现共5页.p
11-22
异步Future机制是Java多线程中用于提升效率和优化资源利用的一种设计模式，它允许我们在主线程中不等待子线程的执行结果，而是通过Future对象来获取子线程的计算结果。这种方式极大地提高了程序的响应速度，尤其是在...
java多线程设计模式详解(PDF及源码)
07-14
（注意，本资源附带书中源代码可供参考） 多线程与并发处理是程序设计好坏优劣的重要课题，本书通过浅显易懂的文字与实例来介绍Java线程相关的设计模式概念，并且通过实际的Java程序范例和 UML图示来一一解说，书中...
java多线程设计模式源码
01-17
Java多线程设计模式是构建高并发、高性能应用的关键技术之一。这些模式通过优化资源利用、提高程序可读性和可维护性，使并发编程更加高效和安全。以下将详细讲解标题和描述中涉及的一些核心知识点： 1. **线程池...
java多线程设计模式详解+源码
07-02
Java多线程设计模式是Java开发中不可或缺的一部分，它涉及到并发编程的核心理论和技术。在Java中，多线程用于提高程序的执行效率，通过同时执行多个任务来利用系统资源。本资料包包含“java多线程设计模式详解”文档...
图解多线程设计模式pdf_图解Java多线程设计模式 PDF 全书扫描版
weixin_30839665的博客
12-24 1177
序章1 Java线程 1I1．1 Java线程 2I1．2 何谓线程 2明为跟踪处理流程，实为跟踪线程 2单线程程序 3多线程程序 4Thread类的run方法和start方法 5I1．3 线程的启动 9线程的启动(1)——利用Thread类的子类 9线程的启动(2)——利用Runnable接口 10I1．4 线程的暂停 12I1．5 线程的互斥处理 13synchronized方法 14sync...
Future异步任务
南城的博客
04-24 924
CompletableFuture实现了CompletableStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 先看一下传统线程池执行异步线程，获取线程处理结果的方式。 public static void main(String[] args) throws Exception { // 创建异步执行任务: ExecutorService executorService= E
Future实现一个简单的异步功能
xiaxiaoying的专栏
02-04 457
在使用ThreadPoolExecutor构建线程池的时候我们可以通过调用submit()方法得到一个Future的结果，这样就实现了一个异步调用方法的功能了，现在我们自己试着来实现一个简单的异步方法 1、首先来看一下Future这个接口里面有哪些内容 里面比较重点的有get()和get(long,TimeUnit)这个两个方法，这两个方法也就是我们异步得到执行结果的关键点咯 2、编写具体的实例 public class FutureTest { volatile boolean i
Future异步
qwert
03-22 1175
Future对象表示一个异步操作的结果，当执行一个异步任务时，可以通过Future对象获取任务的执行状态和结果。在Java中，Future对象通常是通过Executor框架提交的异步任务返回的，可以使用Future.get()方法来获取异步任务的执行结果。如果异步任务尚未完成，则调用Future.get()方法将会阻塞线程，直到异步任务执行完毕并返回结果。Future异步是Java中常用的异步编程方式之一，它能够在等待异步任务结果的同时执行其他操作，提高程序的并发性能。
异步编程-Future
大灰狼的小绵羊哥哥的博客
03-02 1662
Future可以说是在Dart异步编程中随处可见，比如一个网络请求返回的是Future对象，或者访问一个SharedPreferences返回一个Future对象等等。异步操作可以让你的程序在等待一个操作完成时继续处理其它的工作。而Dart 使用Future对象来表示异步操作的结果。我们通过前面文章都知道Dart是一个单线程模型的语言，所以遇到延迟的计算一般都需要采用异步方式来实现，那么Future就是代表这个异步返回的结果。 1. 复习几个概念 1.1 事件循环EventLoop Dart的...
并发模式之异步回调Future模式
mg0324的专栏
07-28 922
在JDK1.5中提供了Future模式，获取数据时阻塞的，所以其他框架（guava和netty)对Future模式做了扩展，支持了回调函数。在JDK1.8中提供了，支持了更加强大的异步回调、流式处理、多个Future组合处理的能力。...
flutter future异步处理
weixin_44911775的博客
07-21 413
1.事件队列有两种，微任务队列(MicroTaskQueue)和事件队列(EventQueue)，微任务队列大于事件队列，future就是事件队列的，所以会先完成普通代码再进行future的代码。3.future是Future类的对象,其表示一个T类型的异步操作结果。如果异步操作不需要结果，则future的类型可为Future。2.Dart单线程,Future作为异步的返回结果是Dart异步中不可或缺的一部分。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值