Async Programming in Rust

# CHAPTER 23

Async Programming in Rust #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the difference between OS Threads and Async tasks.

• Define asynchronous functions using the async keyword.

• Pause execution using the .await keyword.

• Understand the concept of a Future.

• Install and configure the Tokio async runtime.

3. What is Async? (The Kitchen Analogy) #

Async is designed for I/O bound tasks (waiting for network requests, database queries, or file reads).

4. async and await #

// This function doesn't return data immediately. It returns a Future.
async fn fetch_data() -> String {
    String::from("Data fetched from database!")
}

async fn run_program() {
    // .await pauses run_program() until fetch_data() completes.
    // While it is paused, the CPU is free to do other tasks!
    let data = fetch_data().await;
    println!("{}", data);
}

5. The Need for a Runtime (Tokio) #

1. Install Tokio: Add this to your Cargo.toml:

[dependencies]
tokio = { version = "1", features = ["full"] }

2. Setup Tokio in main.rs: By adding the #[tokio::main] macro, Tokio sets up the background engine and allows main to be async!

use tokio::time::{sleep, Duration};

// The macro wraps main in the Tokio runtime
#[tokio::main]
async fn main() {
    println!("Starting task...");

    // Instead of thread::sleep (which blocks the whole thread), 
    // we use tokio::time::sleep (which yields control to the runtime!)
    sleep(Duration::from_secs(2)).await;

    println!("Task finished after 2 seconds!");
}

6. Spawning Async Tasks #

#[tokio::main]
async fn main() {
    // Spawn a lightweight Tokio task
    let handle = tokio::spawn(async {
        println!("Running in a background task!");
        "Result Data"
    });

    println!("Running in main task!");

    // Wait for the background task to finish and get the result
    let result = handle.await.unwrap();
    println!("Background returned: {}", result);
}

7. Common Mistakes #

• Using std::thread::sleep in Async Code: If you use the standard thread sleep inside an async function, you freeze the entire OS thread, completely destroying the benefit of Async. Always use tokio::time::sleep and .await it.

• Forgetting .await: If you call an async fn and forget to .await it, nothing happens! The Future is created but never executed. The compiler will warn you: future is not .await'ed.

8. Best Practices #

• CPU vs I/O: Use Async/Tokio for I/O bound work (APIs, Databases, Files). If you have intense CPU-bound work (like rendering a 3D image or calculating primes), use standard std::thread OS threads.

9. Exercises #

1. 1. Setup a new cargo project and install tokio.

1. 2. Create an async fn getuserid() -> u32 that returns 101.

1. 3. In #[tokio::main], call the function, .await the result, and print it.

10. MCQs with Answers #

11. Interview Questions #

• Q: Explain the difference between an OS Thread and a Tokio async task (Green Thread).

• Q: Why did the Rust language designers choose not to include an Async Runtime in the standard library? (Answer: To keep the standard library incredibly small and suitable for Embedded systems, allowing the community to build tailored runtimes like Tokio).

12. Summary #

13. Next Chapter Recommendation #