From 1c6487c1e79cbe0d59a39b483af8ec44b59c586e Mon Sep 17 00:00:00 2001
From: Chris Boesch <chrboesch@noreply.codeberg.org>
Date: Fri, 3 Apr 2026 18:11:00 +0200
Subject: added async-io quiz

---
 exercises/090_async7.zig | 57 ------------------------------------------------
 1 file changed, 57 deletions(-)
 delete mode 100644 exercises/090_async7.zig

(limited to 'exercises/090_async7.zig')

diff --git a/exercises/090_async7.zig b/exercises/090_async7.zig
deleted file mode 100644
index bfe6ffd..0000000
--- a/exercises/090_async7.zig
+++ /dev/null
@@ -1,57 +0,0 @@
-//
-// When multiple async tasks access shared data, you need
-// synchronization! Io provides a Mutex for this:
-//
-//     var mutex: std.Io.Mutex = .init;
-//
-//     // In a task:
-//     try mutex.lock(io);       // blocks until lock is acquired
-//     defer mutex.unlock();
-//     // ... critical section: safe to modify shared data ...
-//
-// Without the mutex, concurrent tasks could read and write the
-// same memory simultaneously, causing a data race — the result
-// would be unpredictable.
-//
-// mutex.lock() is a cancellation point — it can return
-// error.Canceled. There's also tryLock() which returns
-// immediately (true if acquired, false if not).
-//
-// Fix this program so the counter is correctly synchronized.
-// Without the fix, the final count would be unpredictable.
-// With it, four tasks incrementing 100 times each = 400.
-//
-const std = @import("std");
-const print = std.debug.print;
-
-const SharedState = struct {
-    counter: u32 = 0,
-    mutex: std.Io.Mutex = .init,
-};
-
-pub fn main(init: std.process.Init) !void {
-    const io = init.io;
-    var state = SharedState{};
-
-    var group: std.Io.Group = .init;
-
-    group.async(io, increment, .{ io, &state, 100 });
-    group.async(io, increment, .{ io, &state, 100 });
-    group.async(io, increment, .{ io, &state, 100 });
-    group.async(io, increment, .{ io, &state, 100 });
-
-    try group.await(io);
-
-    print("Counter: {}\n", .{state.counter});
-}
-
-fn increment(io: std.Io, state: *SharedState, times: u32) void {
-    for (0..times) |_| {
-        // Acquire the lock before modifying shared state.
-        // What Mutex method blocks until the lock is acquired?
-        state.mutex.??? catch return;
-        defer state.mutex.unlock(); // <-- what's missing here?
-
-        state.counter += 1;
-    }
-}
-- 
cgit v1.2.3