Crate tokio [] [src]

Future-powered I/O at the core of Tokio

This crate uses the futures crate to provide an event loop ("reactor core") which can be used to drive I/O like TCP and UDP. All asynchronous I/O is powered by the mio crate.

The concrete types provided in this crate are relatively bare bones but are intended to be the essential foundation for further projects needing an event loop. In this crate you'll find:

  • TCP, both streams and listeners.
  • UDP sockets.
  • An event loop to run futures.

More functionality is likely to be added over time, but otherwise the crate is intended to be flexible, with the PollEvented type accepting any type that implements mio::Evented. For example, the tokio-uds crate uses PollEvented to provide support for Unix domain sockets.

Some other important tasks covered by this crate are:

  • All I/O is futures-aware. If any action in this crate returns "not ready" or "would block", then the current future task is scheduled to receive a notification when it would otherwise make progress.

You can find more extensive documentation in terms of tutorials at


A simple TCP echo server:

extern crate futures;
extern crate futures_cpupool;
extern crate tokio;
extern crate tokio_io;

use futures::prelude::*;
use futures::future::Executor;
use futures_cpupool::CpuPool;
use tokio_io::AsyncRead;
use tokio_io::io::copy;
use tokio::net::TcpListener;

fn main() {
    let pool = CpuPool::new_num_cpus();

    // Bind the server's socket.
    let addr = "".parse().unwrap();
    let listener = TcpListener::bind(&addr)
        .expect("unable to bind TCP listener");

    // Pull out a stream of sockets for incoming connections
    let server = listener.incoming().for_each(|sock| {
        // Split up the reading and writing parts of the
        // socket.
        let (reader, writer) = sock.split();

        // A future that echos the data and returns how
        // many bytes were copied...
        let bytes_copied = copy(reader, writer);

        // ... after which we'll print what happened.
        let handle_conn =|amt| {
            println!("wrote {:?} bytes", amt)
        }).map_err(|err| {
            eprintln!("IO error {:?}", err)

        // Spawn the future as a concurrent task.


    // Spin up the server on this thread



Task execution utilities.


TCP/UDP bindings for tokio.


The core reactor driving all I/O.