从 #[tokio::main] 开始

#[tokio::main]
async fn main() {
  println!("hello");
}

fn main() {
  let body = async {
    println!("hello");
  };
  // 编译期检查 future 的输出类型和函数返回类型一致，运行时不会执行
  let body = {
    if false {
      let _: &dyn ::core::future::Future<Output = ()> = &body;
    }
    body
  };
  {
    use tokio::runtime::Builder;
    return Builder::new_multi_thread()
      .enable_all()
      .build()
      .expect("Failed building the Runtime")
      .block_on(body);
  }
}

fn build_threaded_runtime(&mut self) -> io::Result<Runtime> {
    // ...
    let worker_threads = self.worker_threads.unwrap_or_else(num_cpus);

    let (driver, driver_handle) = driver::Driver::new(self.get_cfg())?;

    // Create the blocking pool
    let blocking_pool =
        blocking::create_blocking_pool(self, self.max_blocking_threads + worker_threads, worker_threads);
    let blocking_spawner = blocking_pool.spawner().clone();
    // ...
    let (scheduler, handle, launch) = MultiThread::new(
        worker_threads,
        driver,
        driver_handle,
        blocking_spawner,
        // ...
    );

    let handle = Handle { inner: scheduler::Handle::MultiThread(handle) };

    // Spawn the thread pool workers
    let _enter = handle.enter();
    launch.launch();

    Ok(Runtime::from_parts(Scheduler::MultiThread(scheduler), handle, blocking_pool))
}

impl Launch {
    pub(crate) fn launch(mut self) {
        for worker in self.0.drain(..) {
            runtime::spawn_blocking(move || run(worker));
        }
    }
}

pub(crate) fn block_on<F>(&self, handle: &scheduler::Handle, future: F) -> F::Output
where
    F: Future,
{
    crate::runtime::context::enter_runtime(handle, true, |blocking| {
        blocking.block_on(future).expect("failed to park thread")
    })
}

loop {
    if let Ready(v) = crate::task::coop::budget(|| f.as_mut().poll(&mut cx)) {
        return Ok(v);
    }

    self.park();
}

Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks. If you are in an async function, use `.await` on the future instead of blocking on it.

there is no reactor running, must be called from the context of a Tokio 1.x runtime

pub(super) fn schedule_task(&self, task: Notified, is_yield: bool) {
    // ...
    with_current(|maybe_cx| {
        if let Some(cx) = maybe_cx {
            // Make sure the task is part of the **current** scheduler.
            if self.ptr_eq(&cx.worker.handle) {
                // And the current thread still holds a core
                if let Some(core) = cx.core.borrow_mut().as_mut() {
                    self.schedule_local(core, task, is_yield);
                    return;
                }
            }
        }

        // Otherwise, use the inject queue.
        self.push_remote_task(task);
        self.notify_parked_remote();
    });
}

while !core.is_shutdown {
    // ...
    // Increment the tick
    core.tick();

    // Run maintenance, if needed
    core = self.maintenance(core);

    // First, check work available to the current worker.
    if let Some(task) = core.next_task(&self.worker) {
        core = match self.run_task(task, core) { /* ... */ };
        continue;
    }

    // There is no more **local** work to process, try to steal work
    // from other workers.
    if let Some(task) = core.steal_work(&self.worker) {
        core = match self.run_task(task, core) { /* ... */ };
    } else {
        // Wait for work
        core = /* ... */ self.park(core);
    }
}

A: Some("main")
B: Some("tokio-rt-worker")

C: Some("main")
D: Some("main")