何为Tokio

    • 基于多线程，工作窃取的任务调度程序。
    • 由操作系统的事件队列（epoll，kqueue，IOCP等）支持的反应器。
    • 异步TCP和UDP套接字。
      这些组件提供构建异步应用程序所需的运行时组件。

    Tokio是基于Rust编程语言构建的，它本身非常快。使用Tokio构建的应用程序将获得同样的好处。 Tokio的设计也旨在使应用程序尽可能快。

    Tokio以为基础。Future不是一个新主意，但Tokio使用它们的方式是独一无二的。与其他语言的Future不同，Tokio的Future编译成状态机。用Future实现常见的同步，分配或其他不会增加额外开销成本。

    请注意，提供零成本抽象并不意味着Tokio本身没有成本。这意味着使用Tokio导致最终产品具有与不使用Tokio相同的开销。

    并发

    开箱即用，Tokio提供了一个多线程，工作窃取的调度程序。因此，当您使用tokio :: run开始使用应用程序时，您已经在使用所有计算机的CPU内核。

    现代计算机通过添加内核来提高其性能，因此能够利用多个内核对于编写快速应用程序至关重要。

    非阻塞I/O

    当访问网络时，Tokio将使用操作系统可用的最有效系统。在Linux上，这意味着epoll，* bsd平台提供kqueue，Windows具有I / O完成端口。

    虽然Tokio无法阻止所有错误，但它的目的是最小化它们。它通过提供难以滥用的API来实现这一点。在一天结束时，您可以放心地将应用程序运送到生产中。

    Rust的所有权模型和类型系统可以实现系统级应用程序，而不必担心内存不安全。它可以防止经典错误，例如访问未初始化的内存并免费使用。它在不添加任何运行时开销的情况下执行此操作。

    此外，API能够利用类型系统来提供难以滥用的API。例如，Mutex不要求用户明确解锁：

    背压

    在基于推送的系统中，当生产者生成的数据快于消费者可以处理的数据时，数据将开始备份。待处理数据存储在内存中。除非生产者停止生产，否则系统最终会耗尽内存并崩溃。消费者通知生产者减速的能力是背压。

    因为Tokio使用基于轮询的模型，所以问题大多消失了。生产者默认是懒惰的。除非消费者要求，否则他们不会产生任何数据。这是Tokio的基础。

    消除

    由于Tokio基于轮询的模型，除非对它们进行轮询，否则计算不起作用。该计算的依赖性持有表示该计算结果的Future。如果不再需要结果，则会删除Future。此时，将不再轮询计算，因此不再执行任何工作。

    Tokio可以很好地扩展，而不会增加应用程序的开销，使其能够在资源受限的环境中茁壮成长。

    因为Tokio是基于Rust构建的，所以编译后的可执行文件包含最少的语言运行时。最终产品类似于C ++将生成的产品。这意味着，没有垃圾收集器，没有虚拟机，没有JIT编译，也没有堆栈操作。编写您的服务器应用程序，而不必担心停止世界停顿。

    可以使用Tokio而不会产生任何运行时分配，使其非常适合实时用例。

    模块化

    虽然Tokio提供了很多开箱即用的功能，但它的组织非常模块化。每个组件都位于一个单独的库中。如果需要，应用程序可以选择挑选所需的组件，避免依赖其余组件。

    例子:带有Tokio的基本TCP echo服务器：

    1. extern crate tokio;
    3. use tokio::io::copy;
    4. use tokio::net::TcpListener;
    6. fn main() {
    8.     let addr = "127.0.0.1:12345".parse().unwrap();
    9.     let listener = TcpListener::bind(&addr)
    10.         .expect("unable to bind TCP listener");
    12.     // Pull out a stream of sockets for incoming connections
    13.     let server = listener.incoming()
    14.         .map_err(|e| eprintln!("accept failed = {:?}", e))
    15.         .for_each(|sock| {
    16.             // Split up the reading and writing parts of the
    17.             // socket.
    18.             let (reader, writer) = sock.split();
    19.             // A future that echos the data and returns how
    20.             // many bytes were copied...
    23.             // ... after which we'll print what happened.
    24.             let handle_conn = bytes_copied.map(|amt| {
    25.                 println!("wrote {:?} bytes", amt)
    26.             }).map_err(|err| {
    27.                 eprintln!("IO error {:?}", err)
    28.             });
    30.             // Spawn the future as a concurrent task.
    31.             tokio::spawn(handle_conn)
    32.         });
    34.     // Start the Tokio runtime

    更多例子在