标准库内置async/await能否替代Tokio？是否更推荐使用而非Tokio类crate？

Great question—this is a common point of confusion when diving into Rust's async ecosystem, so let's break it down clearly.

First, let's clarify the distinct roles of these two components:

• The standard library's async/await is a language-level syntax feature paired with the core Future trait. It lets you write asynchronous code in a clean, imperative style, but it doesn't provide any mechanism to execute the asynchronous tasks you define. Think of it as the "blueprint" for async code, not the "engine" that runs it.
• Tokio is an async runtime (plus a robust toolkit of async utilities). It's the engine that takes those Future blueprints and actually runs them, handling task scheduling, async IO operations, timers, and all the low-level plumbing that makes async programming practical.

So, can standard library async/await replace Tokio? #

Short answer: No. The standard library doesn't include an async runtime. If you write an async fn using only the standard library, you'll end up with a Future that's just an inert value in memory—nothing will execute it. To run your async code, you need a runtime like Tokio, async-std, or smol.

For example, this simple async function won't do anything on its own:

async fn hello() {
    println!("Hello, async world!");
}

fn main() {
    // This creates a Future, but doesn't trigger execution
    let future = hello();
    // No output here—nothing is driving the future forward
}

To make it work, you'd use Tokio's runtime (via its convenient macro that handles setup automatically):

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

Is async/await now the "preferred" alternative to Tokio? #

Absolutely not—they're complementary, not competitors. async/await is the standard, idiomatic way to write async code in Rust today, and runtimes like Tokio are built on top of the standard library's Future trait and async syntax. Tokio fully embraces standard library async/await; it's the foundation of how Tokio operates.

If you're starting a new Rust async project today, the recommended approach is:

• Use the standard library's async/await syntax to write your core async logic (this ensures your code is portable across runtimes if needed).
• Choose a mature runtime like Tokio (the most widely adopted for production use) to execute that logic, handle async IO, manage tasks, etc.
• Leverage Tokio's additional utilities (like tokio::fs, tokio::net, or tokio::sync primitives) when you need async versions of standard library features that don't exist natively.

A quick side note #

There are lighter-weight runtimes if you don't need all of Tokio's features (like smol), but Tokio remains the go-to for most production-grade async Rust work. The standard library's async support gives you a consistent way to write async code across all runtimes, but it never eliminates the need for a runtime itself.

内容的提问来源于stack exchange，提问作者utx0_