Programación concurrente en Rust

El manejo seguro y eficiente de la concurrencia es uno de los propósitos del nacimiento de Rust, y resuelve principalmente la capacidad de soportar cargas elevadas en los servidores.

El concepto de concurrencia (concurrent) se refiere a que diferentes partes de un programa se ejecutan de forma independiente, lo cual es fácil de confundir con el concepto de paralelismo (parallel); el paralelismo enfatiza la "ejecución simultánea".

La concurrencia a menudo da lugar al paralelismo.

Este capítulo aborda los conceptos y detalles de programación relacionados con la concurrencia.

Hilos

Un hilo (thread) es una parte de un programa que se ejecuta de forma independiente.

La diferencia entre un hilo y un proceso (process) es que el hilo es un concepto interno al programa; un programa suele ejecutarse dentro de un proceso.

En entornos con sistema operativo, los procesos suelen ejecutarse mediante una planificación alternada, mientras que los hilos son planificados por el propio programa dentro del proceso.

Debido a que la concurrencia de hilos puede fácilmente dar lugar a situaciones de paralelismo, los errores de interbloqueo (deadlock) y de retraso que pueden encontrarse en el paralelismo suelen aparecer en programas con mecanismos de concurrencia.

Para resolver estos problemas, muchos otros lenguajes (como Java y C#) utilizan un software de tiempo de ejecución (runtime) especial para coordinar los recursos, pero esto sin duda reduce enormemente la eficiencia de ejecución del programa.

Los lenguajes C/C++ también admiten múltiples hilos en el nivel más bajo del sistema operativo, pero ni el lenguaje en sí ni su compilador tienen la capacidad de detectar y evitar errores de paralelismo, lo que supone una gran presión para los desarrolladores, quienes necesitan invertir mucho esfuerzo para evitar errores.

Rust no depende de un entorno de tiempo de ejecución, igual que C/C++.

Sin embargo, Rust ha diseñado en el propio lenguaje mecanismos, incluido el sistema de propiedad, para eliminar en la fase de compilación los errores más comunes en la medida de lo posible; esto es algo que otros lenguajes no tienen.

Pero esto no significa que podamos ser descuidados al programar. Hasta ahora, los problemas causados por la concurrencia no se han resuelto por completo a nivel público, y todavía pueden aparecer errores. ¡Hay que tener mucho cuidado al programar con concurrencia!

En Rust, se crea un nuevo hilo mediante la función std::thread::spawn:

Ejemplo

use std::thread;
use std::time::Duration;

fn spawn_function() {
    for i in 0..5 {
        println!("spawned thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

fn main() {
    thread::spawn(spawn_function);

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Resultado de ejecución:

main thread print 0
spawned thread print 0
main thread print 1
spawned thread print 1
main thread print 2
spawned thread print 2

El orden de este resultado puede variar en algunos casos, pero en general se imprime de esta manera.

Este programa tiene un hilo secundario cuyo propósito es imprimir 5 líneas de texto, y el hilo principal imprime tres líneas, pero es evidente que cuando el hilo principal termina, el hilo creado con spawn también finaliza, sin completar todas las impresiones.

El parámetro de la función std::thread::spawn es una función sin argumentos, pero la forma anterior no es la recomendada; podemos usar cierres (closures) para pasar una función como parámetro:

Ejemplo

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }
}

Un cierre es una función anónima que puede almacenarse en una variable o pasarse como parámetro a otras funciones. Los cierres equivalen a las expresiones Lambda en Rust, con el siguiente formato:

|参数1, 参数2, ...| -> 返回值类型 {
    // 函数体
}

Por ejemplo:

Ejemplo

fn main() {
    let inc = |num: i32| -> i32 {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

Resultado de ejecución:

inc(5) = 6

Los cierres pueden omitir la declaración de tipos y usar el mecanismo de inferencia automática de tipos de Rust:

Ejemplo

fn main() {
    let inc = |num| {
        num + 1
    };
    println!("inc(5) = {}", inc(5));
}

El resultado no cambia.

Método join

Ejemplo

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 0..5 {
            println!("spawned thread print {}", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 0..3 {
        println!("main thread print {}", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

Resultado de ejecución:

main thread print 0 
spawned thread print 0 
spawned thread print 1 
main thread print 1 
spawned thread print 2 
main thread print 2 
spawned thread print 3 
spawned thread print 4

El método join permite que el programa no se detenga hasta que el hilo secundario haya terminado de ejecutarse.

move: transferencia forzada de propiedad

Esta es una situación que se encuentra con frecuencia:

Ejemplo

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(|| {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Intentar usar los recursos de la función actual en un hilo secundario ¡es definitivamente un error! El mecanismo de propiedad prohíbe que se produzca esta situación peligrosa, ya que rompería la determinación del mecanismo de propiedad de destruir los recursos. Podemos usar la palabra clave move del cierre para resolverlo:

Ejemplo

use std::thread;

fn main() {
    let s = "hello";
   
    let handle = thread::spawn(move || {
        println!("{}", s);
    });

    handle.join().unwrap();
}

Paso de mensajes

En Rust, una de las principales herramientas para implementar concurrencia mediante paso de mensajes es el canal (channel). El canal consta de dos partes: un transmisor (transmitter) y un receptor (receiver).

std::sync::mpsc contiene los métodos para el paso de mensajes:

Ejemplo

use std::thread;
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {}", received);
}

Resultado de ejecución:

Got: hi

El hilo secundario obtuvo el transmisor tx del hilo principal, llamó a su método send para enviar una cadena, y entonces el hilo principal la recibió a través del receptor correspondiente rx.

Otras extensiones