Programmiersprache Rust 1.63 bekommt Threads, die sich Daten ausleihen dürfen

Im planmäßigen Sechswochentakt ist Rust 1.63 erschienen. Das Release bringt gleich zwei Änderungen, die mit dem Ownership-Konzept von Rust zusammenhängen. Zum einen erlauben Scoped Threads einen flexibleren Umgang mit den Daten für einen Thread und zum anderen lassen sich Dateideskriptoren beziehungsweise -Handles nun mit einem Wrapper versehen, der festlegt, ob sie Eigentum oder ausgeliehen sind.

Threads im Anwendungskontext

Auch wenn Rust das Async-Await-Pattern erst Ende 2019 eingeführt hat, kennt die Programmiersprache bereits seit ihren Anfängen Threads für die nebenläufige Programmierung. Bisher war das Closure für das Erstellen eines Threads mit der Standard-Library über std::thread::spawn mit 'static gekennzeichnet. Die damit markierte statische Lifetime legt fest, dass der Thread die Ownership über alle Parameter in ihrer Closure haben muss. Es ist somit nicht möglich, geborgte (Borrowed) Daten an einen Thread zu übergeben.

Die API std::thread::scope erstellen nun einen Ausführungskontext (Scope), um sogenannte Scoped Threads zu spawnen. Der Kontext garantiert, dass alle darin befindlichen Threads am Ende entweder manuell über join oder automatisch vor dem Verlassen der Funktion zusammengeführt werden. Daher sind Borrows von nicht-'static-Daten an Scoped Threads erlaubt. Folgendes Beispiel aus dem Rust-Blog veranschaulicht die Scoped Threads im ersten Teil mit unveränderlichen und im zweiten mit veränderlichen Borrows:

let mut a = vec![1, 2, 3];
let mut x = 0;

std::thread::scope(|s| {
    s.spawn(|| {
        println!("hello from the first scoped thread");
        // We can borrow `a` here.
        dbg!(&a);
    });
    s.spawn(|| {
        println!("hello from the second scoped thread");
        // We can even mutably borrow `x` here,
        // because no other threads are using it.
        x += a[0] + a[2];
    });
    println!("hello from the main thread");
});

// After the scope, we can modify and access our variables again:
a.push(4);
assert_eq!(x, a.len());

Geliehene Datei-Handles

Eine weitere Neuerung betrifft den Umgang mit Dateien und bezieht sich ebenfalls auf das Ownership-Konzept. Bisher hat Rust für vom Betriebssystem übernommene Dateideskriptoren unter Unix beziehungsweise -Handles unter Windows eine plattformspezifische Repräsentation übernommen. Bei RawFd war aber nicht klar, ob die API Eigentümer des Deskriptors ist oder ihn nur ausgeliehen hat.

Lesen Sie auch

Ferris Talk #11: Memory Management – Speichermanagement in Rust mit Ownership

---

Kommentar: Rust im Linux-Kernel – handeln statt jubeln!

Rust 1.63 führt zusätzliche Wrapper ein, die explizit die Eigentumsverhältnisse festlegen: Ein BorrowedFd ist gliehen, während OwnedFd die Ownership markiert. Für Letzteren schließt das Programm den Deskriptor beim Freigeben.

Erweiterte Blockade

Daneben erweitert das Release den Umgang mit Mutexes und Konstrukten zum Verwalten von Locks in der asynchronen Programmierung. Seit Version 1.62 setzt Rust unter Linux auf eine futex-basierte Implementierung statt wie zuvor auf POSIX Threads. Der Aufruf von Condvar::new, Mutex::new und RwLock::new ist neuerdings im const-Kontext erlaubt.

Schließlich gelten die Non-lexical Lifetimes (NLL) für Borrows nun als stabil. Sie waren zwar bereits Bestandteil von Rust 2018, galten allerdings bisher nur für die Editionen 2018 und 2021, nicht für Rust 2015. Das ändert sich mit dem aktuellen Release. Details dazu finden sich in einem Blogbeitrag von Anfang August.

Weitere Details zu Rust 1.63 lassen sich dem Rust-Blog entnehmen. Wie üblich können Entwicklerinnen und Entwickler, die Rust bereits installiert haben, das aktuelle Release über rustup update stable herunterladen. Für diejenigen, die noch kein Rust verwenden, ist das rustup-Tool auf der Download-Seite separat verfügbar.

Am 9. November veranstalten heise Developer, iX und dpunkt.verlag die zweite Online-Konferenz zu Rust.

(rme)