学习 Rust Futures - Future 和 Stream

转自 https://www.jianshu.com/p/6e3acd12b233

为什么要用 Futures

很多语言都提供了 promises，futures 的支持。他们能让开发者在面对并发，异步等问题的时候，能直接写出更加简单优雅的同步逻辑代码，而不用在处理复杂的 callback 嵌套以及充斥在各地的被 callback 拆散的代码逻辑。

在 Rust 里面，应该很多人用 mio 编写过网络程序。虽然 mio 是一个非常棒的库，并且 TiKV 也使用 mio 处理网络，事件逻辑等，但 mio 太底层，我们仍然需要关注 async I/O，需要写很多 callback，这直接导致了代码的复杂，逻辑的分散。

幸运的是，Rust 提供了 futures 库来提供对 promises 和 futures 的支持，它的核心在于抽象一个 Future trait，提供 zero-cost 的抽象，让上层逻辑自由的去实现组合。同时，Rust 也提供 tokio 组件，来简化 mio 的编程工作，为 async I/O 提供了一站式的解决方案。

所以，后续对 futures 的说明，我们都会基于 tokio 组件来举例。

Hello World

通常，第一个例子都是 Hello World。这里，我们会用 tokio-core 来实现一个简单的 client，先跟远端的 server 建立连接，给 Server 发送 Hello World，并接受 Server 的返回。

 extern crate futures;
 extern crate tokio_core; 
 
 use std::net::ToSocketAddrs;
 
 use futures::Future;
 use tokio_core::reactor::Core;
 use tokio_core::net::TcpStream;
 
 fn main() {
     let mut core = Core::new().unwrap();
     let addr = "127.0.0.1:8080".to_socket_addrs().unwrap().next().unwrap();
 
     let socket = TcpStream::connect(&addr, &core.handle());
 
     let request = socket.and_then(|socket| {
         tokio_core::io::write_all(socket, "Hello World".as_bytes())
     });
     let response = request.and_then(|(socket, _)| {
         tokio_core::io::read_to_end(socket, Vec::new())
     });
 
     let (_, data) = core.run(response).unwrap();
     println!("{}", String::from_utf8_lossy(&data));
 }
 

这里详细说明一下：

• 我们使用 Core::new() 创建了一个 EventLoop
• 得到 EventLoop 的 handle，方便让外面的对象绑定到这个 EventLoop 上面
• 使用 TcpStream::connect() 连接 server，这里需要注意，虽然我们调用了 connect，但是这里只是返回了一个 future，实际的 socket 建立会在后面进行。
• 然后我们通过 and_then来组合后续的操作，and_then 表明如果当前的 future 执行成功，就会开始执行下一个 future。在上面，我们通过 and_then 来分别生成一个 request future，以及更后面的 response future。
• 最后，我们在 run 里面开始执行 response future，它会从开始的 future 执行，直到最后的 future 完成。

当 connect 成功之后，就会执行write_all，当 write_all 执行成功之后，就会执行 read_to_end，最后，得到结果并输出。可以看到，上面虽然各个逻辑是异步的，但我们通过 future，将其转成了同步的代码，并且通过 and_then 将各个 future 给串联起来。

Future

上面只是一个简单的例子，实际 future 能做的更多。在继续之前，我们来看看 futures 的核心 trait，Future。

Future 的关键定义如下：

 trait Future {
     type Item;
     type Error;
 <span class="hljs-function"><span class="hljs-keyword">fn</span> <span class="hljs-title">poll</span></span>(&amp;<span class="hljs-keyword">mut</span> <span class="hljs-keyword">self</span>) -&gt; Poll&lt;Self::Item, Self::Error&gt;;

 <span class="hljs-comment">// ...</span>

}

Future 内部定义了两个关联类型，Item 和 Error，极大的方便了用户自定义 Future。

Future 最关键的函数是 poll，它会检查当前 future 的状态，看时候已经 ready，能对外提供服务，或者出现了错误。

poll 返回 Poll<Self::Item, Self::Error>，Poll 是一个 typedef，定义如下：

 pub type Poll<T, E> = Result<Async<T>, E>;

pub enum Async<T> {
Ready(T),
NotReady,
}

对于 Async，我们知道：

• Ready(T) 表明这个 Future 已经完成，T 就是该 Future 的返回值
• NotReady 表明这个 Future 并没有 ready，我们需要在后续再次调用 poll

在实现自己的 future 的时候，我们需要注意，因为 future 多数都会跟 event loop 一起使用，所以 poll 一定不能 block 整个 event loop。如果 poll 有耗时的操作，我们需要将这些操作放在其他的线程去执行，然后在后续返回结果。

如果 poll 返回 NotReady ，表明这个 Future 并没有完成，我们需要知道何时再次调用这个 future 的 poll。所以， 一个 future 需要给当前的 task 注册一个通知，当这个 future 的值已经 ready，task 会收到这个通知然后让 future 继续执行。关于 task，我们后面在继续讨论。

Stream

上面我们说了 Future，在 futures 库里面另一个重要的 trait 就是 Stream。在 Future 里面，关键的 poll 函数其实处理的是一个值的情况，但有些时候，我们需要处理连续流式的值，譬如对于一个 TCP Listener 来说，它会持续的通过 accept 产生新的客户端连接。对于流式的处理，我们使用 Stream trait。

 trait Stream {
     type Item;
     type Error;
 <span class="hljs-function"><span class="hljs-keyword">fn</span> <span class="hljs-title">poll</span></span>(&amp;<span class="hljs-keyword">mut</span> <span class="hljs-keyword">self</span>) -&gt; Poll&lt;<span class="hljs-built_in">Option</span>&lt;Self::Item&gt;, Self::Error&gt;;

}

可以看到，Stream trait 跟 Future 差不多，最大的区别在于 poll 返回的是一个 Option<Self::Item>，而不是 Self::Item。

如果一个 Stream 结束了，poll 会返回 Ready(None)，后续对于该 Stream 的错误调用都会 panic。

Stream 也是一个特殊的 Future，我们可以使用 into_future 函数将 Stream 转成一个 Future，这样外面就能使用 Future 的 combinator（譬如 and_then，combinator 会在后续讨论）将 Stream 与其他的 Future 连接起来。

Stream Example

前面我们举了 Future 的一个例子，这里我们对 Stream 举例，实现一个简单的 echo 服务。

 let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
 let addr = addr.parse::<SocketAddr>().unwrap();

let mut core = Core::new().unwrap();
let handle = core.handle();

let socket = TcpListener::bind(&addr, &handle).unwrap();
let done = socket.incoming().for_each(move |(socket, _addr)| {
let (reader, writer) = socket.split();
let amt = copy(reader, writer);

 handle.spawn(amt.then(<span class="hljs-keyword">move</span> |_| {
     <span class="hljs-literal">Ok</span>(())
 }));

 <span class="hljs-literal">Ok</span>(())

});

core.run(done).unwrap();

这里详细说明一下：

• 通过 TcpListener::bind 创建一个 listener。
• 通过 incoming 得到一个 Stream，该 Stream 的 Item 是一个 tuple (TcpStream, SocketAddr) 。当我们处理 incoming 的 Stream 的时候，其实就类似循环调用这个 listener 的 accept 函数。
• 然后我们使用 for_each 用来处理上面的 Stream。for_each 会返回一个 Future 对象，然后让外面的的 Core 去执行。因为上面的例子中，TCPListener 会持续接受连接，所以 run 不会结束。

这里我们在说明一下 for_each 接受一个 Stream 的 Item 之后，如何处理的。

• 使用 split 函数将得到 socket 的 reader 和 writer。也就是我们能通过 reader 读 socket 的数据，通过 writer 往 socket 里面写数据。
• 使用 copy 生成一个 Future，copy 会将 reader 的里面读出来的数据，直接写到 writer 里面。
• 使用 handle.spawn 将 copy 生成的 Future 绑定到 event loop 上面。这样我们才能同时处理多个客户端的请求，而不会阻塞 event loop。

这里重点注意下 handle.spawn，编写过 async I/O 的同学应该都知道 socket 都是非阻塞的，也就是，我们不可能通过一次 read 或者 write 就将这个 socket 的数据全部处理完成。所以，我们后续还会重新将 socket 给 register 到 event loop，这样当有新的事件的时候，event loop 会重新调用对应的回调函数。

如果我们直接用 mio，代码是比较难写的，因为要处理很多异步逻辑情况，但现在我们仅仅只需要 spawn，传入一个 Future，当这个 Future 完成的时候就会调用对应的闭包函数。我们现在仅仅需要关注的是 Future 如何编写，传递，而不再需要关注回调怎么写了。上面的例子，当 copy 这个 Future 完成，我们什么都不干返回（当然也可以打印一点东西…），写起来容易了太多。

小结

这里仅仅是简单了介绍了 Future 和 Stream，后面笔者还是深入研究相关的东西，毕竟我们也会在 TiKV 项目里面使用。