

# 外部数据访问的异步I / O.

> 译者：[flink.sojb.cn](https://flink.sojb.cn/)


本页介绍了Flink的API与外部数据存储的异步I / O的使用。对于不熟悉异步或事件驱动编程的用户，有关Futures和事件驱动编程的文章可能是有用的准备。

注：有关异步I / O实用程序的设计和实现的详细信息，请参阅提议和设计文档 [FLIP-12：异步I / O设计和实现](https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=65870673)。

## 需要异步I / O 算子操作

当与外部系统交互时（例如，当使用存储在数据库中的数据来丰富流事件时），需要注意与外部系统的通信延迟不会主导流应用程序的总工作。

天真地访问外部数据库中的数据，例如在a中`MapFunction`，通常意味着**同步**交互：将请求发送到数据库并`MapFunction`等待直到收到响应。在许多情况下，这种等待构成了函数的绝大部分时间。

与数据库的异步交互意味着单个并行函数实例可以同时处理许多请求并同时接收响应。这样，可以通过发送其他请求和接收响应来覆盖等待时间。至少，等待时间在多个请求上摊销。这导致大多数情况下流量吞吐量更高。

![](../img/async_io.svg)

_注意：_通过仅扩展`MapFunction`到非常高的并行度来提高吞吐量在某些情况下也是可能的，但通常会产生非常高的资源成本：拥有更多并行MapFunction实例意味着更多任务，线程，Flink内部网络连接，网络连接到数据库，缓冲区和一般内部副本记录开销。

## 先决条件

如上一节所示，对数据库（或键/值存储）实现适当的异步I / O需要客户端访问支持异步请求的数据库。许多流行的数据库提供这样的客户端

在没有这样的客户端的情况下，可以通过创建多个客户端并使用线程池处理同步调用来尝试将同步客户端转变为有限的并发客户端。但是，这种方法通常比适当的异步客户端效率低。

## 异步I / O API

Flink的Async I / O API允许用户将异步请求客户端与数据流一起使用。API处理与数据流的集成，以及处理顺序，事件时间，容错等。

假设有一个目标数据库的异步客户端，则需要三个部分来实现对数据库的异步I / O流转换：

*   的实现`AsyncFunction`是把请求分派
*   一个_回调_，它接受 算子操作的结果并将其交给`ResultFuture`
*   在DataStream上应用异步I / O 算子操作作为转换

以下代码示例说明了基本模式：

*   [**Java**](#tab_java_0)
*   [**Scala**](#tab_scala_0)



```
// This example implements the asynchronous request and callback with Futures that have the
// interface of Java 8's futures (which is the same one followed by Flink's Future)

/**
 * An implementation of the 'AsyncFunction' that sends requests and sets the callback.
 */
class AsyncDatabaseRequest extends RichAsyncFunction<String, Tuple2<String, String>> {

    /** The database specific client that can issue concurrent requests with callbacks */
    private transient DatabaseClient client;

    @Override
    public void open(Configuration parameters) throws Exception {
        client = new DatabaseClient(host, post, credentials);
    }

    @Override
    public void close() throws Exception {
        client.close();
    }

    @Override
    public void asyncInvoke(String key, final ResultFuture<Tuple2<String, String>> resultFuture) throws Exception {

        // issue the asynchronous request, receive a future for result
        final Future<String> result = client.query(key);

        // set the callback to be executed once the request by the client is complete
        // the callback simply forwards the result to the result future
        CompletableFuture.supplyAsync(new Supplier<String>() {

            @Override
            public String get() {
                try {
                    return result.get();
                } catch (InterruptedException | ExecutionException e) {
                    // Normally handled explicitly.
                    return null;
                }
            }
        }).thenAccept( (String dbResult) -> {
            resultFuture.complete(Collections.singleton(new Tuple2<>(key, dbResult)));
        });
    }
}

// create the original stream
DataStream<String> stream = ...;

// apply the async I/O transformation
DataStream<Tuple2<String, String>> resultStream =
    AsyncDataStream.unorderedWait(stream, new AsyncDatabaseRequest(), 1000, TimeUnit.MILLISECONDS, 100);
```





```
/**
 * An implementation of the 'AsyncFunction' that sends requests and sets the callback.
 */
class AsyncDatabaseRequest extends AsyncFunction[String, (String, String)] {

    /** The database specific client that can issue concurrent requests with callbacks */
    lazy val client: DatabaseClient = new DatabaseClient(host, post, credentials)

    /** The context used for the future callbacks */
    implicit lazy val executor: ExecutionContext = ExecutionContext.fromExecutor(Executors.directExecutor())

    override def asyncInvoke(str: String, resultFuture: ResultFuture[(String, String)]): Unit = {

        // issue the asynchronous request, receive a future for the result
        val resultFutureRequested: Future[String] = client.query(str)

        // set the callback to be executed once the request by the client is complete
        // the callback simply forwards the result to the result future
        resultFutureRequested.onSuccess {
            case result: String => resultFuture.complete(Iterable((str, result)))
        }
    }
}

// create the original stream val stream: DataStream[String] = ...

// apply the async I/O transformation val resultStream: DataStream[(String, String)] =
    AsyncDataStream.unorderedWait(stream, new AsyncDatabaseRequest(), 1000, TimeUnit.MILLISECONDS, 100)
```



**重要提示**：`ResultFuture`在第一次通话时完成`ResultFuture.complete`。所有后续`complete`调用都将被忽略。

以下两个参数控制异步 算子操作​​：

*   **超时**：超时定义异步请求在被视为失败之前可能需要多长时间。此参数可防止死/失败的请求。

*   **容量**：此参数定义可能同时有多少异步请求正在进行中。尽管异步I / O方法通常会带来更好的吞吐量，但算子仍然可能成为流应用程序的瓶颈。限制并发请求的数量可确保算子不会累积不断增加的待处理请求积压，但一旦容量耗尽就会触发反压。

### 超时处理

当异步I / O请求超时时，默认情况下会引发异常并重新启动作业。如果要处理超时，可以覆盖该`AsyncFunction#timeout`方法。

### 结果顺序

由`AsyncFunction`一些未定义的顺序经常完成的并发请求，基于哪个请求首先完成。为了控制发出结果记录的顺序，Flink提供了两种模式：

*   **无序**：异步请求完成后立即发出结果记录。在异步I / O 算子之后，流中记录的顺序与之前不同。当使用_处理时间_作为基本时间特性时，此模式具有最低延迟和最低开销。使用`AsyncDataStream.unorderedWait(...)`此模式。

*   **Ordered**：在这种情况下，保存流顺序。结果记录的发出顺序与触发异步请求的顺序相同（ 算子输入记录的顺序）。为此，算子缓冲结果记录，直到其所有先前记录被发出（或超时）。这通常会在检查点中引入一些额外的延迟和一些开销，因为与无序模式相比，记录或结果在检查点状态下保持更长的时间。使用`AsyncDataStream.orderedWait(...)`此模式。

### 活动时间

当流应用程序与[事件时间](https://flink.sojb.cn/dev/event_time.html)一起工作[时](https://flink.sojb.cn/dev/event_time.html)，异步I / O算子将正确处理水印。这意味着两种订单模式具体如下：

*   **无序**：水印不会超过记录，反之亦然，这意味着水印建立了一个_订单边界_。记录仅在水印之间无序发出。只有在发出水印后才会发出某个水印后发生的记录。反过来，只有在水印发出之前输入的所有结果记录之后才会发出水印。

    这意味着，在水印的存在，将_无序的_方式介绍了一些相同的延迟和管理开销的_订购_模式一样。开销量取决于水印频率。

*   **Ordered**：保存记录的水印顺序，就像保存记录之间的顺序一样。与_处理时间_相比，开销没有显着变化。

请记住，_摄取时间_是_事件时间的_一种特殊情况，其中自动生成的水印基于源处理时间。

### 容错保证

异步I / O 算子提供完全一次的容错保证。它将检查点中的飞行中异步请求的记录存储起来，并在从故障中恢复时恢复/重新触发请求。

### 实施技巧

对于实现_期货_有一个_执行人_（或_执行上下文_在Scala）回调，我们建议使用`DirectExecutor`，因为回调通常做最少的工作，并且`DirectExecutor`避免了额外的线程到线程切换的开销。回调通常只将结果传递给`ResultFuture`，将其添加到输出缓冲区。从那里开始，包括记录发射和与检查点副本记录交互的重要逻辑无论如何都发生在专用线程池中。

A `DirectExecutor`可以通过`org.apache.flink.runtime.concurrent.Executors.directExecutor()`或 获得`com.google.common.util.concurrent.MoreExecutors.directExecutor()`。

### 警告

**AsyncFunction不称为多线程**

我们想在这里明确指出的常见混淆`AsyncFunction`是不以多线程方式调用。只存在一个实例，`AsyncFunction`并且对于流的相应分区中的每个记录顺序调用它。除非该`asyncInvoke(...)`方法快速返回并依赖于回调（由客户端），否则它将不会导致正确的异步I / O.

例如，以下模式会导致阻塞`asyncInvoke(...)`函数，从而使异步行为无效：

*   使用其查找/查询方法调用阻塞的数据库客户端，直到收到结果为止

*   阻止/等待`asyncInvoke(...)`方法内异步客户端返回的future-type对象

