Rust Async Programming async/await

In modern programming, async programming is becoming increasingly important because it allows programs to not be blocked while waiting for I/O operations (such as file reading/writing, network communication, etc.), thereby improving performance and responsiveness.

Async programming is a way to handle non-blocking operations in Rust, allowing programs to not be blocked while performing long-running I/O operations, but instead can execute other tasks while waiting.

Rust provides a variety of tools and libraries for async programming, includingasyncandawaitkeywords,futuresand async runtimes (such as tokio, async-std, etc.), and other auxiliary tools.

Future: Future is an abstraction in Rust that represents an asynchronous operation. It is a computation that may not have completed yet, and will return a value or an error at some point in the future.
async/await：asyncThe keyword is used to define an async function, which returns a Future.awaitThe keyword is used to pause the execution of the current Future until it completes.

Example

The following example demonstrates how to use the async and await keywords to write an async function, and how to execute an async task in an async function and wait for it to complete.

Example

// Import the required dependencies
use tokio;
use tokio::time::{self, Duration};

// Async function, simulating an async task
async fn async_task() -> u32 {
// Simulate an async operation, wait 1 second
time::sleep(Duration::from_secs(1)).await;
// Return the result
42
}

// Async task execution function
async fn execute_async_task() {
// Call the async task and wait for it to complete
let result = async_task().await;
// Output the result
println!("Async task result: {}", result);
}

// Main function
#[tokio::main]
async fn main() {
println!("Start executing async task...");
// Call the async task execution function and wait for it to complete
execute_async_task().await;
println!("Async task completed!");
}

In the code above, we first defined an async functionasync_task(), which simulates an async operation, usingtokio::time::delay_for()method to wait for 1 second, then returns the result 42. Then we defined an async task execution functionexecute_async_task(), in which we called the async function and usedawaitkeyword to wait for the completion of the async task. Finally, inmainfunction, usetokio::mainmacro to run the async task execution function and wait for its completion.

Running this program, you can see that the program outputs a prompt indicating that it started executing the async task, then after waiting 1 second outputs the result of the async task, and finally outputs a prompt indicating that the async task completed:

Start executing async task...
Async task result: 42
Async task completed!

This example demonstrates the use ofasyncandawaitkeywords to write async functions, and how to execute async tasks in async functions and wait for their completion.

The following example uses the tokio library to perform an async HTTP request and outputs the response:

Example 2

// Import the required dependencies
use std::error::Error;
use tokio::runtime::Runtime;
use reqwest::get;

// Async function for performing an HTTP GET request and returning the response
async fn fetch_url(url: &str) -> Result<String, Box<dyn Error>> {
// Use reqwest to make an async HTTP GET request
let response = get(url).await?;
let body = response.text().await?;
Ok(body)
}

// Async task execution function
async fn execute_async_task() -> Result<(), Box<dyn Error>> {
// Make an async HTTP request
let url = "https://jsonplaceholder.typicode.com/posts/1";
let result = fetch_url(url).await?;
// Output the response
println!("Response: {}", result);
Ok(())
}

// Main function
fn main() {
// Create an async runtime
let rt = Runtime::new().unwrap();
// Execute the async task in the async runtime
let result = rt.block_on(execute_async_task());
// Handle the execution result of the async task
match result {
Ok(_) => println!("Async task executed successfully!"),
Err(e) => eprintln!("Error: {}", e),
}
}

In the code above, we first imported the tokio and reqwest libraries, which are used for executing async tasks and making HTTP requests respectively. Then we defined an async function fetch_url, which is used to perform an async HTTP GET request and return the response.

Next, we defined an async task execution function execute_async_task, which makes an async HTTP request and outputs the response.

Finally, in the main function, we created a tokio async runtime, executed the async task within it, and handled the execution result of the async task.

Running this program, you can see the response of the async HTTP request is output. In the example, it requested a post data from JSONPlaceholder and printed its content.

Async Programming Explanation

async keyword

The async keyword is used to define async functions, i.e., functions that return a Future or impl Future type. When an async function is executed, it returns an unfinished Future object, which represents a computation or operation that has not yet completed.

Async functions can contain await expressions, which are used to wait for other async operations to complete.

Example

async fn hello() -> String {
"Hello, world!".to_string()
}

await keyword

The await keyword is used to wait for the completion of an async operation and obtain its result.

The await expression can only be used in async functions or async blocks. It pauses the execution of the current async function, waits for the awaited Future to complete, and then continues to execute subsequent code.

Example

async fn print_hello() {
let result = hello().await;
println!("{}", result);
}

Async Function Return Value

The return type of an async function is usuallyimpl Future<Output = T>, whereTis the result type of the async operation. Since the return value of an async function is a Future, you can use.awaitto wait for the async operation to complete and obtain its result.

Example

async fn add(a: i32, b: i32) -> i32 {
a + b
}

Async Block

In addition to defining async functions, Rust also provides async block syntax, allowing async operations to be used in synchronous code. An async block consists ofasync { }, which can contain async function calls andawaitexpressions.

Example

async {
let result1 = hello().await;
let result2 = add(1, 2).await;
println!("Result: {}, {}", result1, result2);
};

Async Task Execution

In Rust, async tasks usually need to run in an execution context. You can usetokio::main、async-stdoftask::block_onorfutures::executor::block_onand other functions to execute async tasks. These functions accept an async function or async block and execute it in the current thread or execution environment.

Example

use async_std::task;

fn main() {
task::block_on(print_hello());
}

Error Handling

awaitfollowed by a?operator can propagate errors. IfawaitFuture completes with an error, then this error will be propagated to the caller.

Example

async fn my_async_function() -> Result<(), MyError> {
some_async_operation().await?;
// If some_async_operation fails, the error will be propagated
}

Async Trait Methods

Rust allows defining async methods for traits. This enables you to define async operations for objects of different types.

Example

trait MyAsyncTrait {
async fn async_method(&self) -> Result<(), MyError>;
}

impl MyAsyncTrait for MyType {
async fn async_method(&self) -> Result<(), MyError> {
// Async logic
}
}

Async Context

In Rust, async code is usually executed in an async runtime (such as Tokio or async-std). These runtimes provide mechanisms for scheduling and executing async tasks.

Example

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

In the code above,#[tokio::main]The attribute macro wrapsmainthe function in an async runtime.

Async Macros

Rust provides some async macros, such astokio::spawn, which are used to start new async tasks in an async runtime.

Example

#[tokio::main]
async fn main() {
let handle = tokio::spawn(async {
// Async logic
});
handle.await.unwrap();
}

Async I/O

Rust's standard library provides async I/O operations, such astokio::fs::Fileandasync_std::fs::File。

Example

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt};

#[tokio::main]
async fn main() -> io::Result<()> {
let mut file = File::open("file.txt").await?;
let mut contents = String::new();
file.read_to_string(&mut contents).await?;
println!("Contents: {}", contents);
Ok(())
}

Async Channels

Some async runtimes in Rust provide async channels (such as tokio::sync::mpsc), which allow passing messages between async tasks.

Example

use tokio::sync::mpsc;
use tokio::spawn;

#[tokio::main]
async fn main() {
let (tx, mut rx) = mpsc::channel(32);

let child = spawn(async move {
let response = "Hello, world!".to_string();
tx.send(response).await.unwrap();
});

let response = rx.recv().await.unwrap();
println!("Received: {}", response);

child.await.unwrap();
}

Summary

Rust's async programming model async/await provides a concise and efficient way to handle async operations.

It allows developers to handle async operations in a more natural and intuitive way, while maintaining Rust's safety and performance.

Through async/await, Rust provides first-class language support for async programming, making it easier to write efficient and readable async programs.

Other Extensions