Fork-join
Estilo de paralelización donde el cómputo (task) es partido en sub-cómputos menores (subtasks). Los resultados de estos se unen (join) para construir la solución al cómputo inicial.
Partir el cómputo se realiza en general de forma recursiva: los sub-cómputos son independientes → el cómputo se puede realizar en paralelo.
Las sub-tareas se pueden crear en cualquier momento de la ejecución de la tarea.
Las tareas no deben bloquearse, excepto para esperar el final de las subtareas.
Modelo de concurrencia sin condiciones de carrera.
Los programas fork-join son determinísticos, los threads están aislados. El programa produce el mismo resultado independientemente de las diferencias de velocidad de los threads.
Work stealing
Algoritmo usado para hacer scheduling de tareas entre threads. Work stealing (Robo de trabajo): worker threads inactivos roban trabajo a threads ocupados, para realizar balanceo de carga. Los worker threads se comunican solamente cuando lo necesitan → menor necesidad de sincronización.
<aside> <img src="/icons/exclamation-mark_purple.svg" alt="/icons/exclamation-mark_purple.svg" width="40px" /> Si se utilizara una única cola de tareas compartida entre todos los threads, habría una mayor contención por el acceso a la cola. Cada vez que un thread quisiera agregar o tomar una tarea de la cola, tendría que competir con otros threads por el acceso a la cola. Esto podría aumentar el tiempo necesario para acceder a la cola y reducir el rendimiento del sistema.
Además, el uso de una única cola de tareas compartida podría aumentar la necesidad de sincronización entre los threads. Cada vez que un thread quisiera acceder a la cola, tendría que adquirir un bloqueo para evitar que otros threads accedan a la cola al mismo tiempo. Esto podría aumentar la complejidad del código y reducir el rendimiento del sistema.
</aside>
Ejemplo:
use std::fs;
use std::thread;
fn count_lines_in_file(file: &str) -> u32 {
let contents = fs::read_to_string(file).unwrap();
contents.lines().count() as u32
}
fn count_lines_in_directory(dir: &str) -> u32 {
let mut total_lines = 0;
let mut handles = vec![];
for entry in fs::read_dir(dir).unwrap() {
let entry = entry.unwrap();
let path = entry.path();
if path.is_dir() {
handles.push(thread::spawn(move || count_lines_in_directory(path.to_str().unwrap())));
} else {
total_lines += count_lines_in_file(path.to_str().unwrap());
}
}
for handle in handles {
total_lines += handle.join().unwrap();
}
total_lines
}
fn main() {
let dir = "/path/to/dir";
let total_lines = count_lines_in_directory(dir);
println!("Total lines: {}", total_lines);
}