feat: add thread pool

book-src/01-04-file-exists.md

@@ -0,0 +1,6 @@
+# Check file existence
+
+In this example, we use `panic` to ensure `build.zig` should exist.
+```zig
+{{#include ../src/01-04.zig}}
+```

book-src/07-03-threadpool.md

@@ -0,0 +1,12 @@
+## Thread pool
+
+Thread pools address two different problems:
+1. They usually provide improved performance when executing large numbers of asynchronous tasks, due to reduced per-task invocation overhead, and
+2. They provide a means of bounding and managing the resources, including threads, consumed when executing a collection of tasks.
+
+
+In this example, we spawn 10 tasks into thread pool, and use `WaitGroup` to wait for them to finish.
+
+```zig
+{{#include ../src/07-03.zig}}
+```

book-src/SUMMARY.md

@@ -7,6 +7,7 @@
   - [Read file line by line](./01-01-read-file-line-by-line.md)
   - [Mmap file](./01-02-mmap-file.md)
   - [Find Files modified in the last 24 hours](./01-03-file-modified-24h-ago.md)
+  - [Check file existence](./01-04-file-exists.md)
 
 - [Cryptography]()
 
@@ -36,6 +37,7 @@
 
   - [Explicit Threads](./07-01-spawn.md)
   - [Shared Data](./07-02-shared-data.md)
+  - [Thread pool](./07-03-threadpool.md)
 
 - [Operating System]()
 

src/01-04.zig

@@ -0,0 +1,13 @@
+//! Check file existence
+
+const std = @import("std");
+const fs = std.fs;
+
+pub fn main() void {
+    const filename = "build.zig";
+    fs.cwd().access(filename, .{}) catch {
+        std.debug.panic("{s} not exists", .{filename});
+    };
+
+    std.debug.print("{s} exists", .{filename});
+}

src/07-03.zig

@@ -0,0 +1,27 @@
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main() !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var pool: std.Thread.Pool = undefined;
+    try pool.init(.{
+        .allocator = allocator,
+        .n_jobs = 4,
+    });
+    defer pool.deinit();
+
+    var wg: std.Thread.WaitGroup = .{};
+    for (0..10) |i| {
+        pool.spawnWg(&wg, struct {
+            fn run(id: usize) void {
+                print("I'm from {d}\n", .{id});
+            }
+        }.run, .{i});
+    }
+    wg.wait();
+
+    print("All threads exit.\n", .{});
+}