Modul 12 — Concurrency & Threads

Ein Programm kann Arbeit auf mehrere Kerne verteilen: Threads. Der Start ist ein Funktionsaufruf mit einer Closure:

use std::thread;

fn main() {
    let daten = vec![1, 2, 3, 4];

    let handle = thread::spawn(move || {
        let summe: i32 = daten.iter().sum();
        summe * 10
    });

    println!("Ergebnis: {}", handle.join().unwrap());
}

Drei Bausteine: spawn startet die Closure auf einem neuen Thread, move übergibt die gefangenen Daten als Besitz (nicht als Leihe — der Thread könnte den erzeugenden Scope überleben, also würde jede Referenz baumeln), und join() wartet auf das Ende und liefert das Ergebnis. Vergisst du join, endet main möglicherweise zuerst — und der Prozess nimmt den Thread mit ins Grab, bevor er fertig war.

Übung: spawn + join

Der sauberste Weg, Threads Daten austauschen zu lassen: Channels — eine Einbahnstraße für Nachrichten. Go hat den Spruch geprägt: "Do not communicate by sharing memory; share memory by communicating."

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

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

    thread::spawn(move || {
        for n in 1..=3 {
            tx.send(n * n).unwrap();
        }
        drop(tx);
    });

    while let Ok(wert) = rx.recv() {
        println!("{wert}");
    }
}

mpsc heißt: multiple producers, single consumer — viele Sender (Sender clonen), ein Empfänger. send überträgt Besitz der Nachricht, recv wartet blockierend. Und das Ende ist im Typ verankert: gehen alle Sender verloren, liefert recv ein Err — der while-let-Loop endet von selbst. Kein Polling, keine Magic-Values: die Kanal-Schließung IST ein Wert.

Übung: der Quadrat-Kanal

Manchmal willst du Daten nicht kopieren oder schicken, sondern wirklich teilen. Dann braucht es zwei Teile: einen Schloss-Mechanismus und einen thread-sicheren Besitz.

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

fn main() {
    let zaehler = Arc::new(Mutex::new(0u32));

    let mut handles = Vec::new();
    for _ in 0..4 {
        let z = Arc::clone(&zaehler);
        handles.push(thread::spawn(move || {
            *z.lock().unwrap() += 10;
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("Zähler: {}", *zaehler.lock().unwrap());
}

Mutex ist das Schloss: lock() gibt dir einen Guard — nur über ihn erreichst du die Daten, und beim Drop des Guards gibt er das Schloss frei. Das Schloss-Umgehen ist unmöglich, die Daten liegen ja EINGESPERRT im Mutex. Arc ist Rc mit atomarem Zähler — der einzige Grund, warum dieselbe Struktur über Threads geteilt werden darf.

Beides zusammen ist die Standard-Antwort auf "vier Threads, ein Zähler" — und der Compiler erzwingt die Kombination: Rc-Container verweigert er mit E0277, ein Mutex ohne Teilung wäre sinnlos.

Übung: der geteilte Zähler

Der Abschluss: eine Million Zahlen, zwei Kerne, eine Antwort. Das Szenario:

Modul-Checkpoint