Flink使用AsyncDataStream异步处理数据--性能提升效果

已于 2022-06-27 13:00:42 修改
阅读量1.4k 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： flink java 大数据 unorderedwait orderedwait
于 2022-06-25 10:46:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27818541/article/details/125455916
本文通过实例展示了20条数据同步与异步处理方式下，每条任务2秒耗时情况下，总耗时的明显区别。同步方式下耗时40秒，异步方式下仅8秒，探讨了并行和顺序执行对效率的影响。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

转载请标明出处：
https://bigmaning.blog.csdn.net/article/details/125455916
本文出自:【BigManing的博客】

场景需求

一共有20条数据，每条数据处理需要2秒，分别使用同步、异步方式处理，一共需要多久才能处理完呢？

接下来进行简单的验证，如有疑惑，欢迎指正。

同步方式

使用map算子模拟同步

代码

	/**
     * 同步方式  
     */
    private static void syncHandleData() throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        env.generateSequence(1, 20)
                .map(aLong -> {
                    return handleData(aLong);
                });
        env.execute("test");
    }

    /**
     * 模拟业务 耗时2s操作
     *
     */
    private static Long handleData(Long aLong) throws InterruptedException {
        String dateTime = DateFormatUtils.ISO_DATETIME_FORMAT.format(new Date());
        System.out.println(dateTime + "====> 处理第" + aLong + "个任务... 开始 " + Thread.currentThread().getName());
        // 模拟 耗时2s处理
        Thread.sleep(2000);
        dateTime = DateFormatUtils.ISO_DATETIME_FORMAT.format(new Date());
        System.out.println(dateTime + "====> 处理第" + aLong + "个任务... 结束");
        return aLong;
    }

结果输出

从以下结果可以得出结论：

  1. 每个任务都是按照顺序执行的
  2. 每个任务都是耗时2s（）
  3. 总耗时为 20*2 = 40s
2022-06-25T09:53:39====> 处理第1个任务... 开始 Thread-7
2022-06-25T09:53:41====> 处理第1个任务... 结束
2022-06-25T09:53:41====> 处理第2个任务... 开始 Thread-7
2022-06-25T09:53:43====> 处理第2个任务... 结束
2022-06-25T09:53:43====> 处理第3个任务... 开始 Thread-7
2022-06-25T09:53:45====> 处理第3个任务... 结束
2022-06-25T09:53:45====> 处理第4个任务... 开始 Thread-7
2022-06-25T09:53:47====> 处理第4个任务... 结束
2022-06-25T09:53:47====> 处理第5个任务... 开始 Thread-7
2022-06-25T09:53:49====> 处理第5个任务... 结束
2022-06-25T09:53:49====> 处理第6个任务... 开始 Thread-7
2022-06-25T09:53:51====> 处理第6个任务... 结束
2022-06-25T09:53:51====> 处理第7个任务... 开始 Thread-7
2022-06-25T09:53:53====> 处理第7个任务... 结束
2022-06-25T09:53:53====> 处理第8个任务... 开始 Thread-7
2022-06-25T09:53:55====> 处理第8个任务... 结束
2022-06-25T09:53:55====> 处理第9个任务... 开始 Thread-7
2022-06-25T09:53:57====> 处理第9个任务... 结束
2022-06-25T09:53:57====> 处理第10个任务... 开始 Thread-7
2022-06-25T09:53:59====> 处理第10个任务... 结束
2022-06-25T09:53:59====> 处理第11个任务... 开始 Thread-7
2022-06-25T09:54:01====> 处理第11个任务... 结束
2022-06-25T09:54:01====> 处理第12个任务... 开始 Thread-7
2022-06-25T09:54:03====> 处理第12个任务... 结束
2022-06-25T09:54:03====> 处理第13个任务... 开始 Thread-7
2022-06-25T09:54:05====> 处理第13个任务... 结束
2022-06-25T09:54:05====> 处理第14个任务... 开始 Thread-7
2022-06-25T09:54:07====> 处理第14个任务... 结束
2022-06-25T09:54:07====> 处理第15个任务... 开始 Thread-7
2022-06-25T09:54:09====> 处理第15个任务... 结束
2022-06-25T09:54:09====> 处理第16个任务... 开始 Thread-7
2022-06-25T09:54:11====> 处理第16个任务... 结束
2022-06-25T09:54:11====> 处理第17个任务... 开始 Thread-7
2022-06-25T09:54:13====> 处理第17个任务... 结束
2022-06-25T09:54:13====> 处理第18个任务... 开始 Thread-7
2022-06-25T09:54:15====> 处理第18个任务... 结束
2022-06-25T09:54:15====> 处理第19个任务... 开始 Thread-7
2022-06-25T09:54:17====> 处理第19个任务... 结束
2022-06-25T09:54:17====> 处理第20个任务... 开始 Thread-7
2022-06-25T09:54:19====> 处理第20个任务... 结束

异步方式

使用AsyncDataStream数据流，因为我们不需要关注顺序，所以使用unorderedWait方法。如果你需要关注顺序，可以使用orderedWait方法。

代码


    /**
     * 异步方式
     */
    private static void asyncHandleData() throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Long> longDataStreamSource = env.generateSequence(1, 20);
        // 不用关心顺序，异步处理完直接发送到下游
        AsyncDataStream.unorderedWait(longDataStreamSource, new MyRichAsyncFunction(), 1, TimeUnit.MINUTES, 5);
        env.execute("test");
    }

    /**
     * RichAsyncFunction 异步处理Function 实现类
     */
    static class MyRichAsyncFunction extends RichAsyncFunction<Long, Long> {

        private ThreadPoolExecutor threadPoolExecutor;

        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            // 初始化操作
            threadPoolExecutor = new ThreadPoolExecutor(5, 10, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>());
        }

        @Override
        public void close() throws Exception {
            super.close();
            // 善后操作
            threadPoolExecutor.shutdown();
        }

        @Override
        public void timeout(Long input, ResultFuture<Long> resultFuture) throws Exception {
            // 超时操作
            resultFuture.completeExceptionally(new TimeoutException());
        }

        @Override
        public void asyncInvoke(Long aLong, ResultFuture<Long> resultFuture) throws Exception {
            // 异步客户端处理
            CompletableFuture.runAsync(() -> {
                try {
                    handleData(aLong);
                } catch (InterruptedException e) {
                    resultFuture.completeExceptionally(e);
                    return;
                }
                resultFuture.complete(Collections.singleton(aLong));
            }, threadPoolExecutor);
        }

    }
    
    /**
     * 模拟 耗时2s操作
     */
    private static Long handleData(Long aLong) throws InterruptedException {
        String dateTime = DateFormatUtils.ISO_DATETIME_FORMAT.format(new Date());
        System.out.println(dateTime + "====> 处理第" + aLong + "个任务... 开始 " + Thread.currentThread().getName());
        // 模拟 耗时2s处理
        Thread.sleep(2000);
        dateTime = DateFormatUtils.ISO_DATETIME_FORMAT.format(new Date());
        System.out.println(dateTime + "====> 处理第" + aLong + "个任务... 结束");
        return aLong;
    }

结果输出

从以下结果可以得出结论：

  1. 任务是异步并发处理的
  2. 由于是AsyncDataStream.unorderedWait，所以顺序是无序的
  3. 总耗时为 8s （2022-06-25T10:23:09 - 2022-06-25T10:23:01）
2022-06-25T10:23:01====> 处理第4个任务... 开始 pool-3-thread-4
2022-06-25T10:23:01====> 处理第2个任务... 开始 pool-3-thread-2
2022-06-25T10:23:01====> 处理第5个任务... 开始 pool-3-thread-5
2022-06-25T10:23:01====> 处理第3个任务... 开始 pool-3-thread-3
2022-06-25T10:23:01====> 处理第1个任务... 开始 pool-3-thread-1
2022-06-25T10:23:03====> 处理第4个任务... 结束
2022-06-25T10:23:03====> 处理第2个任务... 结束
2022-06-25T10:23:03====> 处理第1个任务... 结束
2022-06-25T10:23:03====> 处理第3个任务... 结束
2022-06-25T10:23:03====> 处理第5个任务... 结束
2022-06-25T10:23:03====> 处理第6个任务... 开始 pool-3-thread-4
2022-06-25T10:23:03====> 处理第7个任务... 开始 pool-3-thread-2
2022-06-25T10:23:03====> 处理第8个任务... 开始 pool-3-thread-1
2022-06-25T10:23:03====> 处理第9个任务... 开始 pool-3-thread-3
2022-06-25T10:23:03====> 处理第10个任务... 开始 pool-3-thread-5
2022-06-25T10:23:05====> 处理第6个任务... 结束
2022-06-25T10:23:05====> 处理第7个任务... 结束
2022-06-25T10:23:05====> 处理第8个任务... 结束
2022-06-25T10:23:05====> 处理第9个任务... 结束
2022-06-25T10:23:05====> 处理第11个任务... 开始 pool-3-thread-4
2022-06-25T10:23:05====> 处理第10个任务... 结束
2022-06-25T10:23:05====> 处理第12个任务... 开始 pool-3-thread-1
2022-06-25T10:23:05====> 处理第13个任务... 开始 pool-3-thread-2
2022-06-25T10:23:05====> 处理第14个任务... 开始 pool-3-thread-3
2022-06-25T10:23:05====> 处理第15个任务... 开始 pool-3-thread-5
2022-06-25T10:23:07====> 处理第13个任务... 结束
2022-06-25T10:23:07====> 处理第15个任务... 结束
2022-06-25T10:23:07====> 处理第11个任务... 结束
2022-06-25T10:23:07====> 处理第12个任务... 结束
2022-06-25T10:23:07====> 处理第14个任务... 结束
2022-06-25T10:23:07====> 处理第16个任务... 开始 pool-3-thread-3
2022-06-25T10:23:07====> 处理第17个任务... 开始 pool-3-thread-5
2022-06-25T10:23:07====> 处理第18个任务... 开始 pool-3-thread-4
2022-06-25T10:23:07====> 处理第19个任务... 开始 pool-3-thread-1
2022-06-25T10:23:07====> 处理第20个任务... 开始 pool-3-thread-2
2022-06-25T10:23:09====> 处理第18个任务... 结束
2022-06-25T10:23:09====> 处理第17个任务... 结束
2022-06-25T10:23:09====> 处理第16个任务... 结束
2022-06-25T10:23:09====> 处理第19个任务... 结束
2022-06-25T10:23:09====> 处理第20个任务... 结束

延伸

使用orderedWait会有什么样的表现呢？

代码修改如下：


    /**
     * 异步方式
     */
    private static void asyncHandleData() throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);
        DataStreamSource<Long> longDataStreamSource = env.generateSequence(1, 20);
        // 关心顺序，使用orderedWait， 异步处理完 并且是位于队列第一个 才发送到下游
        AsyncDataStream.orderedWait(longDataStreamSource, new MyRichAsyncFunction(), 1, TimeUnit.MINUTES, 5)//     
                //  验证 orderedWait   
                .print("打印结果：");
        env.execute("test");
    }

运行结果：

2022-06-25T10:39:57====> 处理第2个任务... 开始 pool-3-thread-2
2022-06-25T10:39:57====> 处理第4个任务... 开始 pool-3-thread-4
2022-06-25T10:39:57====> 处理第5个任务... 开始 pool-3-thread-5
2022-06-25T10:39:57====> 处理第3个任务... 开始 pool-3-thread-3
2022-06-25T10:39:57====> 处理第1个任务... 开始 pool-3-thread-1
2022-06-25T10:39:59====> 处理第4个任务... 结束
2022-06-25T10:39:59====> 处理第1个任务... 结束
2022-06-25T10:39:59====> 处理第2个任务... 结束
2022-06-25T10:39:59====> 处理第3个任务... 结束
2022-06-25T10:39:59====> 处理第5个任务... 结束
打印结果：> 1
打印结果：> 2
打印结果：> 3
打印结果：> 4
打印结果：> 5
2022-06-25T10:39:59====> 处理第6个任务... 开始 pool-3-thread-1
2022-06-25T10:39:59====> 处理第7个任务... 开始 pool-3-thread-2
2022-06-25T10:39:59====> 处理第8个任务... 开始 pool-3-thread-4
2022-06-25T10:39:59====> 处理第9个任务... 开始 pool-3-thread-3
2022-06-25T10:39:59====> 处理第10个任务... 开始 pool-3-thread-5
2022-06-25T10:40:01====> 处理第9个任务... 结束
2022-06-25T10:40:01====> 处理第6个任务... 结束
2022-06-25T10:40:01====> 处理第8个任务... 结束
2022-06-25T10:40:01====> 处理第7个任务... 结束
2022-06-25T10:40:01====> 处理第10个任务... 结束
打印结果：> 6
打印结果：> 7
打印结果：> 8
打印结果：> 9
打印结果：> 10
2022-06-25T10:40:01====> 处理第11个任务... 开始 pool-3-thread-3
2022-06-25T10:40:01====> 处理第12个任务... 开始 pool-3-thread-1
2022-06-25T10:40:01====> 处理第13个任务... 开始 pool-3-thread-4
2022-06-25T10:40:01====> 处理第14个任务... 开始 pool-3-thread-2
2022-06-25T10:40:01====> 处理第15个任务... 开始 pool-3-thread-5
2022-06-25T10:40:03====> 处理第11个任务... 结束
2022-06-25T10:40:03====> 处理第12个任务... 结束
2022-06-25T10:40:03====> 处理第13个任务... 结束
打印结果：> 11
打印结果：> 12
打印结果：> 13
2022-06-25T10:40:03====> 处理第14个任务... 结束
2022-06-25T10:40:03====> 处理第15个任务... 结束
2022-06-25T10:40:03====> 处理第16个任务... 开始 pool-3-thread-2
打印结果：> 14
2022-06-25T10:40:03====> 处理第17个任务... 开始 pool-3-thread-1
打印结果：> 15
2022-06-25T10:40:03====> 处理第18个任务... 开始 pool-3-thread-4
2022-06-25T10:40:03====> 处理第19个任务... 开始 pool-3-thread-3
2022-06-25T10:40:03====> 处理第20个任务... 开始 pool-3-thread-5
2022-06-25T10:40:05====> 处理第16个任务... 结束
打印结果：> 16
2022-06-25T10:40:05====> 处理第17个任务... 结束
2022-06-25T10:40:05====> 处理第19个任务... 结束
2022-06-25T10:40:05====> 处理第18个任务... 结束
打印结果：> 17
2022-06-25T10:40:05====> 处理第20个任务... 结束
打印结果：> 18
打印结果：> 19
打印结果：> 20
Flink中的异步I_O和批处理集成
AI天才研究院
05-31 767
Flink中的异步I/O和批处理集成 作者：禅与计算机程序设计艺术 1. 背景介绍 1.1 Flink概述 Apache Flink是一个开源的分布式流处理和批处理框架,它旨在以高吞吐量和低延迟的方式处理无界和有界数据流。F
揭秘大数据领域Flink的异步IO操作
大数据洞察的博客
05-04 526
随着实时数据处理需求的爆发式增长，大数据框架需要在高并发场景下处理海量IO操作。传统同步IO模型在面对高延迟外部系统（如数据库、分布式存储）时，会导致线程阻塞，严重影响吞吐量。Flink的异步IO机制通过异步化改造，允许在等待IO结果时继续处理其他事件，成为突破IO瓶颈的核心技术。本文将深入解析该机制的设计原理、实现细节及应用实践，覆盖从基础概念到高级优化的全流程。核心概念：对比同步/异步IO，解析Flink异步IO架构原理实现：异步函数设计、Future机制、线程池管理数学建模。
Flink之AsyncDataStream
a724952091的博客
09-14 5465
在flink使用过程中，虽然flink有state(状态)可以用来存储很多的缓存数据，但是不可避免的要与其他如redis，hbase 发生交互，除了这些数据库外 更常见的是可能业务需要去调个api填充信息，默认情况下，在MapFunction中，单个并行只能用同步方式去交互: 将请求发送到外部存储，IO阻塞，等待请求返回，然后继续发送下一个请求。这种同步交互的方式往往在网络等待上就耗费了大量时间 。 Flink 在1.2中引入了Async I/O，在异步模式下,将IO操作异步化，单个并行可以连续发送多个请
flink- AsyncDataStream 异步处理
龍承leo
02-25 3028
1、AsyncDataStream有2个方法：unorderedWait表示数据不需要关注顺序，处理完立即发送，orderedWait表示数据需要关注顺序，为了实现该目标，操作算子会在该结果记录之前的记录为发送之前缓存该记录。这往往会引入额外的延迟和一些Checkpoint负载，因为相比于无序模式结果记录会保存在Checkpoint状态内部较长的时间。 ...
Flink DataStream Aysnc IO 实现原理
最新发布
SmartSi
05-19 75
Flink 的 Async I/O 功能旨在解决流计算系统中与外部系统交互时的网络延迟问题。通过异步模式，系统可以并发处理多个请求和回复，避免同步访问中的阻塞等待，从而提高吞吐量和降低延迟。Flink 提供了简洁的 API，支持有序和无序两种输出模式，并通过 AsyncWaitOperator 实现异步操作。AsyncWaitOperator 内部由 StreamElementQueue 和 Emitter 组成，分别负责管理未完成的请求队列和发送完成的消息。Flink 还通过不同的队列实现方式，确保了消息
Flink DataStream Async I/O(异步IO)
Widsom的博客
10-31 2169
Flink DataStream Async I/O(异步IO) 当我们在Operator算子中，需要与外部系统交互时（例如：查询数据库），如果我们使用同步的方式，那么容易造成该Operator计算延迟，吞吐量低。所以Flink 提供了Async I/O机制，可以通过异步操作，处理查询数据库等类似耗时的操作。 与数据库的异步交互意味着单个并行函数实例可以同时处理许多请求并同时接收响应。这样，等待时...
Flink之异步请求AsyncDataStream生产问题记录
为一个人走几座城
04-29 1758
最近生产在搞实时统计需求，在开发环境进行开发的初期，想通过Flink的AsyncDataStream.orderedWait()异步请求的方式，将统计结果最终落地到数据库中。过程中需要查询一些MongoDB中维表的数据，本地测试数据量可能不是很大，所以没有问题。但是当到生产上运行后，就出现了下述问题： java.util.concurrent.RejectedExecutionException: java.lang.IllegalStateException: Mailbox is in state
ActiveJ框架学习——Async I/O之Datastream（一）
m0_46761289的博客
10-31 294
2021SC@SDUSC 概述： Datastream is an extremely fast implementation of reactive streams. It is useful for intra and inter-server communication and asynchronous data processing. Datastream是一个非常快速的反应式流的实现。 它对服务器内和服务器间的 通信和异步数据处理非常有用 特点： 一个现代的异步反应流的实现（不同.
Flink源码分析--(一)异步I/O访问外部数据：AsyncWaitOperator
LS_ice的专栏
05-28 1246
文章目录一、异步I/O概述二、创建AsyncWaitOperator 一、异步I/O概述 Flink流计算系统中经常需要与外部系统进行交互，比如需要查询外部数据库以关联上用户的额外信息。通常，我们的实现方式是向数据库发送用户a的查询请求(例如在MapFunction中，同步方式访问)，然后等待结果返回，在这之前，我们无法发送用户b的查询请求 Flink的Async I/O允许用户在数据流中使...
【Flink实战系列】Flink异步IO访问mysql和redis
JasonLee实时计算
02-23 2658
流计算系统中经常需要与外部系统进行交互，比如需要查询外部数据库以关联上用户的额外信息。通常，我们的实现方式是向数据库发送用户a的查询请求(例如在MapFunction中)，然后等待结果返回，在这之前，我们无法发送用户b的查询请求。这是一种同步访问的模式，为了提高性能阿里向Flink提交了异步IO访问第三方存储的方式，大幅度的提升了程序的性能。 这个问题其实是上次遗留的问题,当时是写了scala的...
Apache Flink 异步I/O机制：Flink AsyncI/O 的创新实践
AI天才研究院
09-25 846
在大数据流处理领域,实时性和吞吐量一直是两个关键的挑战。传统的同步I/O模式会阻塞整个流处理管道,限制了系统的吞吐量。为了解决这个问题,Apache Flink引入了异步I/O机制,通过非阻塞的异步请求大幅提升吞吐量,同时保证了端到端的一致性。拦截算子的同步I/O请求,转换为异步请求异步请求返回后,将结果缓存并注册回调函数根据水位线判断异步结果是否就绪就绪的异步结果被输出,未就绪的继续等待超时的异步请求按照既定逻辑处理这个过程兼顾了低延迟和高吞吐,同时确保了结果的正确性和有序性。
Flink之外部数据访问的异步 I/O
蔡政洁的博客
03-27 785
目录（1）对于异步 I/O 操作的需求（2）异步 I/O API超时处理结果的顺序事件时间容错保证（3）代码实现 （1）对于异步 I/O 操作的需求 在与外部系统交互（用数据库中的数据扩充流数据）的时候，需要考虑与外部系统的通信延迟对整个流处理应用的影响。 简单地访问外部数据库的数据，比如使用 MapFunction，通常意味着同步交互： MapFunction 向数据库发送一个请求然后一直等待，直到收到响应。在许多情况下，等待占据了函数运行的大部分时间。 与数据库异步交互是指一个并行函数实例可以并发地处理
ActiveJ框架学习——Async I/O之Datastream（二）
m0_46761289的博客
12-25 321
2021SC@SDUSC 该篇继上文继续来看Datastream的代码，在这之前，让我们回顾一下什么是Datastream。 Datastream is an extremely fast implementation of reactive streams. It is useful for intra and inter-server communication and asynchronous data processing. Datastream是一个非常快速的反应式流的实现。 它对服务器.
30.DataStream API之Operators(Async IO)
木子李的博客
10-12 478
flink 1.9 本页阐述了使用Flink的API来进行外部数据存储的异步I/O，对于不熟悉异步或者事件驱动编程的用户，学习一篇关于Future和事件驱动编程可能会很有用。 注意:关于异步I/O的详细设计和实现可以在异步I/O设计和实现这篇文章找到(FLIP-12: Asynchronous I/O Design and Implementation)。 The need for A...
Flink DataStream之Asynchronous I/O原理解析
不清不慎的博客
05-04 3191
文章大纲： Async IO的概述以及使用 Async IO的原理 一、Async IO概述 1.什么是Async IO 对于IO，我们都清楚有同步IO和异步IO，那么在Flink中，什么是Async IO，它是怎么样应用的呢？在有些流式应用的场合中，我们都会去与外部系统进行交互，比如连接数据库等。当我们需要向外部系统发送一个请求a的时候，我们需要等待它返回结果，这是同步的模式。考虑到吞吐...
【FLINK】实时流读取维表（二）Async I/O
Zsigner的博客
01-18 704
1、aysnc i/o 的设计 The following diagram illustrates how the streaming records are processed while arriving at AsyncWaitOperator recovering from task failover snapshotting state being emitted by Emitter Thread 来源：FLIP-12: Asynchronous I/O Design and Imp
Flink 异步I/O
breakout_alex的博客
07-17 888
1.为什么需要异步IO flink在做实时处理时，有时候需要和外部数据交互，但是通常情况下这个交互过程是同步的，这样就会产生大量的等待时间；而异步操作可以在单个函数实例中同时处理多个请求，并且同时接收相应。这样等待时间就平均分摊到了多个请求上，大大减少了请求的等待时长，可以提高实时处理的吞吐量。 2.使用flink异步IO的先决条件 需要所连接的数据库支持异步客户端 在没有异步客户端的情况下，可以通过创建多个客户端并使用线程池处理同步调用来尝试将同步客户端转变为有限的并发客户端 3. flink
flink 异步IO AsyncFunction
yang灬仔
03-19 1392
flink使用AsyncFunction 在流式处理的过程中, 在中间步骤的处理中, 如果涉及到一些费事的操作或者是外部系统的数据交互, 那么就会给整个流造成一定的延迟. 在 flink 的 1.2 版本中引入了 Asynchronous I/O, 能够支持异步的操作, 以提高 flink 系统与外部数据系统交互的性能及吞吐量. 在使用 Flink 的异步 IO 时, 主要有两个 API可以使用, 一个是AsyncDataStream.unorderedWait( ), ...
Flink DataStream流表与维表Join(Async I/O)
王佩的CSDN博客
07-20 8047
在Flink 流处理过程中，经常需要和外部系统进行交互，如维度补全，用维度表补全事实表中的字段。默认情况下，在MapFunction中，单个并行只能用同步方式去交互: 将请求发送到外部存储，IO阻塞，等待请求返回，然后继续发送下一个请求。这种同步交互的方式往往在网络等待上就耗费了大量时间。为了提高处理效率，可以增加MapFunction的并行度，但增加并行度就意味着更多的资源，并不是一种非常好的解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值