• Resumen Programación Asincrónica

Martes

• Programacion Asincronica:

  <aside> 💡 Asynchronous programming, or async for short, is a concurrent programming model that lets you run a large number of concurrent tasks on a small number of OS threads, while preserving much of the look and feel of ordinary synchronous programming, through the async/await syntax.

  </aside>

Util para

• Cuando creo muchos threads tal que la memoria ocupada por ellos es significativa. Se puede usar Tareas asincrónicas de Rust para intercalar tareas en un thread o en un pool de threads.
  • Reducen el overhead de memoria ya que son mucho mas liveanas que los threads.
  • Las tareas son más rápidas de crear, más eficiente de pasarle el control a ellas.

No util para

• Computo Intensivo
• Mucho computo y poco I/O
• No me preocupa la cant de mem ocupada (de threads)

Diapositivas

3-async.pdf

Notas

3-async.pdf

Notas - Cap 20

Modelo await/async

<aside> 💡 Importante:

• async devuelve un Future al cual se le debe hacer pull (con block_on o await)

• await debe estar dentro de una funcion async

• Cuando llega a un await el programa no avanza de ese punto hasta que devuelve una respuesta (un Result con el valor o con error)

• Si hay varios await en una funcion, entonces avanza hasta el siguiente await, lo espero, y sigue asi hasta terminar la funcion asincronica.

• block_on traduce el mundo async al sync.

• block_on siempre se llama desde una funcion sincronica.

• Nunca usar block_on desde una funcion asincronica porque rompe con el modelo de concurrencia colaborativa .

</aside>

Ejemplos en Rust

async fn hello() -> String {
    println!("before hello");
    task::sleep(Duration::from_secs(2)).await;
    println!("after hello");
    String::from("Hello")
}

async fn world() -> String {
    println!("before world");
    task::sleep(Duration::from_secs(1)).await;
    println!("after world");
    String::from(" World!")
}

async fn async_main() -> String {
    hello().await + world().await.as_str() 
// Espera ambas awaits antes de retornar con el String.
// Mientras espera, retorna Pending 
}

fn main() {
    println!("{}", task::block_on(async_main()));
// block_on se encarga de administrar las tareas en el thread.
// El codigo no avanza hasta que block_on devuelva una respuesta a imprimir
		println!("Termine");
}

Ver ejemplo de creacion y espera de tareas en Tarea

Clase Grabada

https://drive.google.com/file/d/1LCuDdwxxTRFh-db_vulJFFM4VDG7Roqc/view

Referencias

• Programming Rust: Fast, Safe Systems Development, 2nd Edition Principles of concurrent programming 2nd Edition https://drive.google.com/file/d/1dR9sD1dg5r5_lT58oqlusJMT7_2iSnWm/view?usp=drive_link