await en Rust

Nilesh Katuwal 18 agosto 2022

Rust Rust Asynchronous

En este artículo, aprenderemos el significado de esperar en Rust.

`esperar` en Rust

async-await es una técnica para escribir funciones que pueden hacer una pausa, ceder el control al tiempo de ejecución y luego reanudar la ejecución donde la dejaron. Por lo general, estas pausas se usan para esperar E/S, pero pueden tener varios propósitos.

async-await puede resultarle familiar desde JavaScript o C#. Sin embargo, la implementación de la funcionalidad de Rust tiene algunos cambios importantes.

Para utilizar async-await, debe reemplazar fn con async fn:

async fn new_fxn() -> u32 { .. }

A diferencia de una función convencional, llamar a un async fn no tiene un efecto inmediato. En su lugar, devuelve un futuro.

El cálculo está suspendido y esperando a ser ejecutado. Usa el operador .await para ejecutar el futuro:

async fn second_fxn () {
    let future = new_fxn();

    let result: u32 = future.await;
    ...
}

Este ejemplo ilustra la primera distinción entre Rust y otros lenguajes: escribimos future.await en lugar de await future. Esta sintaxis interactúa mejor con el ? de Rust operador para propagar errores, que son comunes en E/S.

Puedes escribir future.await? cargar con las faltas y esperar el resultado de mucho. Además, tiene el beneficio de hacer que el método de encadenamiento sea indoloro.

El término await solo se puede usar en el contexto de funciones asíncronas, y solo se pueden esperar funciones asíncronas.

Los futures de Rust son laxos; de forma predeterminada, no harán nada antes de que se realice la primera encuesta. Cuando se espera el future, éste es inspeccionado.

Por ejemplo, si llama a una función que devuelve un futuro al comienzo de su programa pero no lo espera hasta el final del programa, la solicitud real no se ejecutará hasta que usted la espere.

Ejemplo:

use std::thread;
use tokio::time::{sleep, Duration};
use futures::future;

#[tokio::main]
async fn main(){
    let mut await_demo = Vec::new();

    for count in 1..=5
    {
        await_demo.push(tokio::spawn(async move{
            println!("Start the thread {count}, id= {:?}", thread::current().id());
            sleep (Duration::from_millis(5000)).await;
            println!("end the thread {count}, id = {:?})", thread::current().id());
        }));
    }
    future::join_all (await_demo).await;
}

En primer lugar, se crean cinco futures (cinco bloques async), y cada future crea un futuro sleep y llama a “esperar”. Estos futures existen simultáneamente.

Cada bloque muestra la identificación del hilo antes y después de await.

Producción :

Standard Output
Start the thread 1, id= ThreadId(2)
Start the thread 3, id= ThreadId(2)
Start the thread 4, id= ThreadId(2)
Start the thread 5, id= ThreadId(2)
Start the thread 2, id= ThreadId(3)
end the thread 2, id = ThreadId(2))
end the thread 3, id = ThreadId(3))
end the thread 1, id = ThreadId(3))
end the thread 4, id = ThreadId(3))
end the thread 5, id = ThreadId(3))

esperar en Rust

`esperar` en Rust