An executor for isolating blocking I/O in async programs.

Sometimes there's no way to avoid blocking I/O. Consider files or stdin, which have weak async support on modern operating systems. While IOCP, AIO, and io_uring are possible solutions, they're not always available or ideal.

Since blocking is not allowed inside futures, we must move blocking I/O onto a special thread pool provided by this crate. The pool dynamically spawns and stops threads depending on the current number of running I/O jobs.

Note that there is a limit on the number of active threads. Once that limit is hit, a running job has to finish before others get a chance to run. When a thread is idle, it waits for the next job or shuts down after a certain timeout.

Await a blocking I/O operation with Blocking::new():

use blocking::Blocking;
use std::fs;

let contents = Blocking::new(|| fs::read_to_string("file.txt")).await?;

Or do the same with the blocking! macro:

use blocking::blocking;
use std::fs;

let contents = blocking!(fs::read_to_string("file.txt"))?;

Read a file and pipe its contents to stdout:

use blocking::Blocking;
use std::fs::File;
use std::io::stdout;

let input = Blocking::new(File::open("file.txt")?);
let mut output = Blocking::new(stdout());

futures::io::copy(input, &mut output).await?;

Iterate over the contents of a directory:

use blocking::Blocking;
use futures::prelude::*;
use std::fs;

let mut dir = Blocking::new(fs::read_dir(".")?);

while let Some(item) = dir.next().await {
    println!("{}", item?.file_name().to_string_lossy());
}

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.