Problema

Si una app va creando muchos threads, cada uno puede tener 100kb de stack. Puede ser un problema la demanda de memoria.

Solución

Se puede usar Tareas asincrónicas de Rust para intercalar tareas en un único thread o en un pool de threads.

• Son mucho más livianas que los threads.
• Más rápidas de crear, más eficiente de pasarle el control a ellas.
• Menor overhead de memoria.

→ Se puede tener miles o decenas de miles en un programa.

El código asincrónico luce como el de threads, salvo que las operaciones que bloquean, se manejan diferente.

No son administrados por el scheduler, sino por un executor.

Ejemplos

Ejemplo 1

Versión sincrónica (threads)

use std::{ net, thread };
// Passive server socket
let listener = net::TcpListener::bind(address)?;
// Block the thread until a connection is received
for socket_result in listener.incoming() {
    let socket = socket_result?; // Socket connected with the client
    let groups = chat_group_table.clone();
    thread::spawn(|| {
		    // Create the thread with spawn per client
        log_error(serve(socket, groups));
    });
}

Versión asincrónica

Es muy similar al sincrónico pero pongo await en las operaciones que son bloqueantes.

Le indico a la tarea que cuando se bloquea puede encargarse de hacer otra cosa mientras.

use async_std::{net, task};

let listener = net::TcpListener::bind(address).await?;
let mut new_connections = listener.incoming();

while let Some(socket_result) = new_connections.next().await {
    let socket = socket_result?;
    let groups = chat_group_table.clone();

    task::spawn(async {
        log_error(serve(socket, groups).await);
    });
}

• Bind ya no es bloqueante.
• Esperar la nueva conexión ya no es bloqueante.
• task → thread. Ahora spawnea funciones asíncronas.

Conceptos de Programación Asincrónica

• Futures
• Funciones Asincrónicas
• Expresiones Await
• Tareas (tasks)
• Executors: block_on y spawn_local
• Tipo Pin

Futures