RwLock en Rust

Muchos lectores o un escritor: el lock indicado cuando dominan las lecturas.

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

fn main() {
    let table = Arc::new(RwLock::new(vec!["basics".to_string()]));

    let writer = {
        let table = Arc::clone(&table);
        thread::spawn(move || {
            table.write().unwrap().push("errors".to_string());
        })
    };
    writer.join().unwrap();

    let readers: Vec<_> = (0..3)
        .map(|id| {
            let table = Arc::clone(&table);
            thread::spawn(move || {
                let tours = table.read().unwrap();
                println!("{id} sees {} tours", tours.len());
            })
        })
        .collect();

    for r in readers {
        r.join().unwrap();
    }
}

Cómo funciona

1. read puede estar en manos de varios hilos a la vez.
2. write espera a que todos los lectores terminen.
3. Ambos devuelven guards que se liberan con el drop.

Palabras clave y builtins usados aquí

• Vec
• fn
• for
• in
• let
• move
• use

El intento, en números

Líneas

28

Caracteres a escribir

514

Tokens

195

Ritmo de tres estrellas

105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 111 segundos.

Escribe este fragmento

Paso 2 de 3 en Estado compartido; paso 5 de 15 en Concurrencia y async.

← Anterior Siguiente →