Rust: Concurrencia

danigm — Sat, 08 Apr 2017 00:00:00 +0200

La programación concurrente es algo básico a día de hoy para poder sacar el máximo rendimiento a los ordenadores modernos con múltiples cores. Sin embargo es también de lo más complejo programar cualquier cosa compartiendo memoria, hay que tener mucho cuidado y añadir semáforos y gestionar manualmente el acceso a memoria compartida, cualquier despiste puede ser un gran problema.

Rust facilita la programación concurrente con las comprobaciones que se hacen en tiempo de compilación y con la gestión de memoria que realiza, el sistema de propiedad de la memoria que implementa Rust nos asegura que no ocurrirán "data race" y esto es válido también para la programación concurrente, por lo que una vez compilado tenemos la certeza de que la gestión de la memoria compartida es correcta y que no habrá ningún "segmentation fault" porque un hilo se ejecute antes que otro y elimine la memoria compartida, etc.

Hilos

Empecemos con un ejemplo muy básico con el uso de hilos en Rust y vayamos viendo el tratamiento de las variables compartidas según lo complicamos.

use std::thread;

fn main() {
    thread::spawn(|| {
        println!("Hello from a thread!");
    });
}

ejecutar

En este ejemplo básico creamos un hilo con thread::spawn, que recibe un closure y se lanza justo al definirlo. Si ejecutamos este ejemplo no saldrá nada por pantalla, ya que el proceso inicial termina antes de que el hilo llegue a ejecutarse e imprimir. Para esperar a que un hilo termine se puede utilizar el método join.

use std::thread;

fn main() {
    let child = thread::spawn(|| {
        println!("Hello from a thread!");
    });
    let _ = child.join();
}

ejecutar

Podemos lanzar varios hilos dentro de un bucle:

use std::thread;

fn main() {
    let mut childs = vec![];

    for i in 0..10 {
        let child = thread::spawn(move || {
            println!("Hello from a thread! {}", i);
        });
        childs.push(child);
    }

    for c in childs {
        let _ = c.join();
    }
}

ejecutar

En este ejemplo ya hay varias cosas que hay que explicar, porque empezamos a compartir memoria. Creamos un Vec donde metemos todos los hilos para luego poder hacer un join y esperar a que todos terminen. Dentro del hilo imprimimos por pantalla el índice de la iteración.

Hemos tenido que añadir move en el closure del hilo, ya que si no lo usamos, el compilador se quejará de que el closure puede vivir más allá de i. Al poner el move lo que hacemos es que en lugar de borrow se hace move de las variables utilizadas dentro del closure, y en este caso nos permite utilizar i dentro del hilo.

Al ser i un entero, el move nos vale perfectamente, porque se copia la memoria, y podríamos acceder al valor de i después de lanzar el hilo sin problemas. Sin embargo si queremos compartir un String, no sería posible ya que para el siguiente hilo la cadena se ha movido.

use std::thread;

fn main() {
    let mut childs = vec![];
    let shared = String::from("Shared string");

    for i in 0..10 {
        let child = thread::spawn(move || {
            println!("Hello from a thread! {} - {}", shared, i);
        });
        childs.push(child);
    }

    for c in childs {
        let _ = c.join();
    }
}

error[E0382]: capture of moved value: `shared`
 --> src/main.rs:9:54
  |
8 |         let child = thread::spawn(move || {
  |                                   ------- value moved (into closure) here
9 |             println!("Hello from a thread! {} - {}", shared, i);
  |                                                      ^^^^^^ value captured here after move
  |
  = note: move occurs because `shared` has type `std::string::String`, which does not implement the `Copy` trait

Esto se puede solucionar clonando la cadena antes, y en este caso, no compartiremos memoria, sino que estamos usando una variable diferente para cada hilo.

Si queremos compartir realmente una referencia a memoria entre hilos tenemos que usar los tipos Arc y Mutex en combinación.

Arc / Mutex

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let mut childs = vec![];
    let shared = Arc::new(Mutex::new(String::from("")));

    for i in 0..10 {
        let s = shared.clone();
        let child = thread::spawn(move || {
            println!("In thread {}", i);

            let out = String::from("Thread ") + &i.to_string() + "\n";
            s.lock().unwrap().push_str(&out);
        });
        childs.push(child);
    }

    for c in childs {
        let _ = c.join();
    }

    println!("\nOutput:\n{}", *(shared.lock().unwrap()));
}

ejecutar

En este ejemplo definimos la cadena dentro de un Mutex y este dentro de un Arc, así podemos compartir realmente la memoria entre hilos.

Arc es un contador de referencias que se puede compartir entre hilos, por lo tanto, el clone no copia la memoria, sino que crea una nueva referencia.

Mutex implementa el bloqueo asociado a la variable en concreto, por lo tanto para acceder a esta variable es necesario llamar al método lock, que nos asegura que podemos leer o modificar esta variable sin que haya condiciones de carrera entre hilos.

A diferencia de otros lenguajes, el Mutex asociado a los datos hace más simple el acceso y nos asegura que no hay condiciones de carrera, ya que si no utilizamos estos tipos e intentamos compartir memoria entre hilos el compilador se quejará.

Canales

Además de compartir variables con Arc/Mutex, hay otra forma de comunicar diferentes hilos de forma relativamente sencilla, usando canales.

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

fn main() {
    let (tx, rx) = mpsc::channel();
    let mut childs = vec![];

    for i in 0..10 {
        let tx = tx.clone();
        let child = thread::spawn(move || {
            println!("In thread {}", i);

            let out = String::from("Thread ") + &i.to_string();
            tx.send(out).unwrap();
        });
        childs.push(child);
    }

    for c in childs {
        let _ = c.join();
    }

    println!("\nOutput:");
    loop {
        match rx.try_recv() {
            Ok(x) => println!("{}", x),
            Err(_) => break
        }
    }
}

ejecutar

Con channel creamos un transmisor, tx, y un receptor, rx, en cada hilo, clonamos el transmisor y escribimos ahí nuestra salida, en el send podemos enviar cualquier tipo de dato según se cree el channel, no se pueden enviar diferentes tipos de datos por el mismo canal.

Usando el receptor se puede leer del canal, en este ejemplo leemos cuando todos los hilos han terminado, pero el método recv se puede usar en cualquier momento y bloqueará la ejecución hasta que se envíe algo por el canal.

Bibliotecas externas

Además de usar los threads básicos de Rust, existen otras muchas bibliotecas que nos ofrecen otras formas de hacer programación concurrente, aquí pongo algunos enlaces:

danigm.net - threads

Rust: Concurrencia

Hilos

Arc / Mutex

Canales

Bibliotecas externas