Zig: Nebenläufigkeit und Spickzettel

Kurz: fn arbeiter(id: usize, ergebnis: usize) void { var summe: usize = 0; for (0..1000) |i| summe += i * id; ergebnis. = summe; }

Teil des Kurses Zig

Kapitel 8 von 8 im Kurs Zig (Abschnitt „Nachschlagen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Nebenläufigkeit

const std = @import("std");
 
fn arbeiter(id: usize, ergebnis: *usize) void {
    var summe: usize = 0;
    for (0..1000) |i| summe += i * id;
    ergebnis.* = summe;
}
 
pub fn main() !void {
    const out = std.io.getStdOut().writer();
    var ergebnisse = [_]usize{0} ** 4;
    var threads: [4]std.Thread = undefined;
    for (&threads, 0..) |*t, i| {
        t.* = try std.Thread.spawn(.{}, arbeiter, .{ i + 1, &ergebnisse[i] });
    }
    for (threads) |t| t.join();
    try out.print("{any}\n", .{ergebnisse});
 
    var mutex = std.Thread.Mutex{};
    var zaehler: u32 = 0;
    const Helfer = struct {
        fn lauf(m: *std.Thread.Mutex, z: *u32) void {
            for (0..1000) |_| {
                m.lock();
                defer m.unlock();
                z.* += 1;
            }
        }
    };
    var ts: [3]std.Thread = undefined;
    for (&ts) |*t| t.* = try std.Thread.spawn(.{}, Helfer.lauf, .{ &mutex, &zaehler });
    for (ts) |t| t.join();
    try out.print("{d}\n", .{zaehler});
}

Ausgabe:

{ 499500, 999000, 1498500, 1998000 }
3000

Spickzettel

Thema	Syntax
Variable	const x = 1; var y: i32 = 2;
Funktion	fn f(a: i32) i32 { return a; }
Fehlerunion	fn g() !i32, try g(), g() catch 0
Optional	?T, x orelse 0, `if (x)
Zeiger	*T, &x, p.*; Multi-Item [*]T; Slice []T
Array	[3]i32{1,2,3}, [_]i32{...}, a.len, a[1..3]
Schleifen	while (c) : (i += 1), `for (liste, 0..)
Struct	const S = struct { a: i32, fn m(self: S) void {} };
Enum/Union	enum { a, b }, union(enum) { x: i32, y: f32 }
Aufräumen	defer, errdefer
Generics	fn Liste(comptime T: type) type { return struct {...}; }
Builtins	@import @cImport @as @intCast @sizeOf @typeName @tagName @panic @min @max

Häufige Fehler

Meldung	Ursache
unused local constant	Variable nie benutzt: entfernen oder _ = x;
local variable is never mutated	var statt const
expected type 'u8', found 'i32'	explizit umwandeln: @intCast
error: expected type 'void', found '...'	Rückgabewert ignoriert: _ = f(); oder try
index out of bounds (Panic)	Zugriff außerhalb des Arrays/Slices
integer overflow (Panic)	Debug-Modus fängt Überlauf: +% oder größerer Typ
memory address ... leaked	Allokation nie freigegeben (defer alloc.free(...))
std-Funktion existiert nicht	Zig ändert sich zwischen Versionen: Doku der installierten Version lesen (zig std)

Weiterlernen

• ziglang.org/documentation (Sprachreferenz), Ziglings (Übungen zum Reparieren), zig.guide
• Quellcode der Standardbibliothek (lib/std) ist gut lesbar
• Projekte zum Lernen: Bun, TigerBeetle, Ghostty, Mach (Spiele-Engine)
• Wiki dieser Seite: Artikel zu Systemprogrammierung

Merke

• Threads über std.Thread, Synchronisierung mit Mutex
• Zig ist noch vor 1.0: Versionen können inkompatibel sein
• Spickzettel: try, catch, defer, comptime, Allocators

Quiz zur Selbstkontrolle

Wie startet man einen Thread in Zig?

• std.Thread.spawn (richtig)
• thread.start()
• async
• fork nur

Wofür dient ein Mutex?

• Exklusiver Zugriff auf gemeinsame Daten (richtig)
• Schnelleres Rechnen
• Speicher freigeben
• Fehler abfangen

Wo findet man Hilfe zur installierten Zig-Version?

• Dokumentation der Version und lib/std (richtig)
• Nirgends
• Nur in C-Headern
• In Makefiles

Weiter im Kurs

Zurück: C-Interop und Build-System

Alle Kapitel: Zig im Überblick