tokio_core::reactor::Core hangs on a threaded scheduler

[gabrielrussoc]

Version

├── tokio v0.2.20
│   └── tokio-macros v0.2.5
└── tokio-core v0.1.17
    ├── tokio v0.1.22
    │   ├── tokio-codec v0.1.2
    │   │   └── tokio-io v0.1.13
    │   ├── tokio-current-thread v0.1.7
    │   │   └── tokio-executor v0.1.10
    │   ├── tokio-executor v0.1.10 (*)
    │   ├── tokio-fs v0.1.7
    │   │   ├── tokio-io v0.1.13 (*)
    │   │   └── tokio-threadpool v0.1.18
    │   │       └── tokio-executor v0.1.10 (*)
    │   ├── tokio-io v0.1.13 (*)
    │   ├── tokio-reactor v0.1.12
    │   │   ├── tokio-executor v0.1.10 (*)
    │   │   ├── tokio-io v0.1.13 (*)
    │   │   └── tokio-sync v0.1.8
    │   ├── tokio-sync v0.1.8 (*)
    │   ├── tokio-tcp v0.1.4
    │   │   ├── tokio-io v0.1.13 (*)
    │   │   └── tokio-reactor v0.1.12 (*)
    │   ├── tokio-threadpool v0.1.18 (*)
    │   ├── tokio-timer v0.2.13
    │   │   └── tokio-executor v0.1.10 (*)
    │   ├── tokio-udp v0.1.6
    │   │   ├── tokio-codec v0.1.2 (*)
    │   │   ├── tokio-io v0.1.13 (*)
    │   │   └── tokio-reactor v0.1.12 (*)
    │   └── tokio-uds v0.2.6
    │       ├── tokio-codec v0.1.2 (*)
    │       ├── tokio-io v0.1.13 (*)
    │       └── tokio-reactor v0.1.12 (*)
    ├── tokio-executor v0.1.10 (*)
    ├── tokio-io v0.1.13 (*)
    ├── tokio-reactor v0.1.12 (*)
    └── tokio-timer v0.2.13 (*)

full version tree: https://pastebin.com/L2jPWrJf

Platform

Linux ... 4.16.18 ... Wed Jan 15 09:20:21 PST 2020 x86_64 x86_64 x86_64 GNU/Linux

Subcrates

tokio-core

Description

Converting a future 0.3 to a future 0.1 and then running it on tokio::reactor::Core inside a threaded scheduler causes the code to hang.

Simple repro (available on this repo):

use futures::future::{FutureExt, TryFutureExt};

async fn do_work() {
    let mut core = tokio_core::reactor::Core::new().unwrap();
    let future03 = async {
        tokio::time::delay_for(std::time::Duration::from_millis(100)).await;
    };
    let res = core.run(future03.unit_error().boxed_local().compat());
    assert!(res.is_ok());
    println!("We good");
}

#[tokio::main]
async fn main() {
    do_work().await;
}

#[tokio::test]
async fn test() {
    do_work().await;
}

cargo test hangs
cargo run works

[Darksonn]

If you block all of the executor's threads, then any future that relies on the executor (e.g. Tokio's time driver) will deadlock. The #[tokio::test] macro fails because it uses only one thread by default, whereas #[tokio::main] worked because you ran it on a computer with more than one cpu core.

To be specific, the core.run call blocks the surrounding Tokio executor. This is expected behaviour.

[gabrielrussoc]

Using #[tokio::test(core_threads=2)] does the trick indeed. Thanks for clarifying.

[Darksonn]

That said, you shouldn't be doing this in the first case. What do you need tokio-core for, and why can't you run it outside of Tokio's worker threads?

[carllerche]

if you need to do this, run tokio_core in a spawn_blocking closure.

[gabrielrussoc]

@Darksonn We have some legacy code using futures 0.1 and we eventually ended up on that situation by awaiting a future inside the core (on chain of calls). It's a bug on our code, but it wasn't clear to me at the time.