fix: 调整协程信号屏蔽处理位置和简化抢占信号处理器

- 将信号屏蔽的恢复操作移到关键区结束后执行
- 简化抢占信号处理器的实现，使用Resume/Suspend替代手动上下文切换
- 调整测试代码以更好地验证时间片抢占效果

Author: funnywwh

.vscode/launch.json

@@ -1,16 +1,22 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
     "configurations": [
-        {
-            "name": "Debug",
-            "type": "gdb",
-            "request": "launch",
-            "target": "./zig-out/bin/zco",
-            "cwd": "${workspaceRoot}",
-            "valuesFormatting": "parseText"
-        }
+    {
+        "name": "C/C++ Debug (gdb Launch)",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "${workspaceFolder}/zig-out/bin/zco",
+        "args": [],
+        "stopAtEntry": true,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "MIMode": "gdb",
+        "setupCommands": [
+            {
+                "description": "Enable pretty-printing for gdb",
+                "text": "-enable-pretty-printing",
+                "ignoreFailures": true
+            }
+        ]
+    }
     ]
 }

src/co.zig

@@ -43,6 +43,9 @@ pub fn Resume(self: *Co) !void {
 
             // 增加切换计数（在关中断状态下安全）
             schedule.total_switches.raw += 1;
+            // 恢复信号
+            _ = c.pthread_sigmask(c.SIG_SETMASK, &oldset, null);
+            // === 关键区结束 ===
 
             // 启动定时器（在协程开始运行前，重置计时）
             schedule.startTimer() catch |e| {
@@ -71,6 +74,9 @@ pub fn Resume(self: *Co) !void {
 
             // 增加切换计数（在关中断状态下安全）
             schedule.total_switches.raw += 1;
+            // 恢复信号
+            _ = c.pthread_sigmask(c.SIG_SETMASK, &oldset, null);
+            // === 关键区结束 ===
 
             // 启动定时器（在协程开始运行前，重置计时）
             schedule.startTimer() catch |e| {
@@ -138,13 +144,12 @@ pub const Co = struct {
             // 停止定时器（协程挂起时）
             self.schedule.stopTimer();
             self.schedule.runningCo = null;
-
-            const swap_result = c.swapcontext(&co.ctx, &schedule.ctx);
-
             // 恢复信号
             _ = c.pthread_sigmask(c.SIG_SETMASK, &oldset, null);
             // === 关键区结束 ===
 
+            const swap_result = c.swapcontext(&co.ctx, &schedule.ctx);
+
             if (swap_result != 0) return error.swapcontext;
 
             if (self.schedule.exit) {

src/main.zig

@@ -23,8 +23,9 @@ pub fn main() !void {
     // const t5 = try std.Thread.spawn(.{}, testDataChan, .{});
     // t5.join();
 
-    const t6 = try std.Thread.spawn(.{}, testTimerLifecycle, .{});
-    t6.join();
+    // const t6 = try std.Thread.spawn(.{}, testTimerLifecycle, .{});
+    // t6.join();
+    try testPreemption();
 }
 
 pub fn testDataChan() !void {
@@ -268,18 +269,18 @@ pub fn testPreemption() !void {
             }.run, .{&counter2});
 
             // 暂时禁用协程3，只测试协程1和协程2的抢占
-            // _ = try s.go(struct {
-            //     fn run() !void {
-            //         const schedule = try zco.getSchedule();
-            //         const co = try schedule.getCurrentCo();
-            //         var i: usize = 0;
-            //         while (i < 20) : (i += 1) {
-            //             try co.Sleep(100 * std.time.ns_per_ms); // 睡眠100ms
-            //             std.log.info("状态检查协程运行中... {} (观察抢占效果)", .{i});
-            //         }
-            //         std.log.info("状态检查协程完成", .{});
-            //     }
-            // }.run, .{});
+            _ = try s.go(struct {
+                fn run() !void {
+                    const schedule = try zco.getSchedule();
+                    const co = try schedule.getCurrentCo();
+                    var i: usize = 0;
+                    while (i < 20) : (i += 1) {
+                        try co.Sleep(100 * std.time.ns_per_ms); // 睡眠100ms
+                        std.log.info("状态检查协程运行中... {} (观察抢占效果)", .{i});
+                    }
+                    std.log.info("状态检查协程完成", .{});
+                }
+            }.run, .{});
 
             std.log.info("开始运行调度器，测试时间片抢占...", .{});
             std.log.info("如果时间片抢占正常工作，应该看到协程1和协程2交替输出进度", .{});
@@ -341,29 +342,31 @@ pub fn testTimerLifecycle() !void {
                 }
             }.run, .{&counter2});
 
-            // 协程3：短时间运行，用于观察调度效果
-            _ = try s.go(struct {
-                fn run() !void {
-                    const schedule = try zco.getSchedule();
-                    const co = try schedule.getCurrentCo();
-                    std.log.info("协程3开始运行（短时间，会主动让出CPU）", .{});
+            // // 协程3：短时间运行，用于观察调度效果
+            // _ = try s.go(struct {
+            //     fn run() !void {
+            //         const schedule = try zco.getSchedule();
+            //         const co = try schedule.getCurrentCo();
+            //         std.log.info("协程3开始运行（短时间，会主动让出CPU）", .{});
 
-                    for (0..10) |i| {
-                        std.log.info("协程3: 步骤 {}", .{i});
-                        try co.Suspend(); // 主动挂起
-                        try co.Sleep(50 * std.time.ns_per_ms); // 睡眠50ms
-                    }
+            //         for (0..10) |i| {
+            //             std.log.info("协程3: 步骤 {}", .{i});
+            //             try co.Suspend(); // 主动挂起
+            //             try co.Sleep(50 * std.time.ns_per_ms); // 睡眠50ms
+            //         }
 
-                    std.log.info("协程3完成", .{});
-                }
-            }.run, .{});
+            //         std.log.info("协程3完成", .{});
+            //     }
+            // }.run, .{});
 
             std.log.info("开始运行调度器，测试时间片抢占...", .{});
             std.log.info("如果时间片抢占正常工作，应该看到协程1和协程2交替输出进度", .{});
 
             // 主协程等待一段时间
-            const mainCo = try s.getCurrentCo();
-            try mainCo.Sleep(5 * std.time.ns_per_s);
+            // const mainCo = try s.getCurrentCo();
+            // try mainCo.Sleep(5 * std.time.ns_per_s);
+
+            std.time.sleep(10 * std.time.ns_per_s);
 
             std.log.info("测试完成！", .{});
             std.log.info("协程1最终计数: {}", .{counter1});

src/schedule.zig

@@ -47,59 +47,20 @@ pub const Schedule = struct {
 
     // 抢占信号处理器 - 使用关中断方式，彻底解决竞态条件
     fn preemptSigHandler(_: c_int, _: [*c]c.siginfo_t, uctx_ptr: ?*anyopaque) callconv(.C) void {
+        _ = uctx_ptr;
         const schedule = localSchedule orelse return;
 
-        // 立即屏蔽SIGALRM信号，防止嵌套调用
-        var sigset: c.sigset_t = undefined;
-        var oldset: c.sigset_t = undefined;
-        _ = c.sigemptyset(&sigset);
-        _ = c.sigaddset(&sigset, c.SIGALRM);
-        _ = c.sigprocmask(c.SIG_BLOCK, &sigset, &oldset);
-
         // 在关中断状态下安全地获取runningCo
         const co = schedule.runningCo orelse {
-            _ = c.sigprocmask(c.SIG_SETMASK, &oldset, null);
+            // _ = c.sigprocmask(c.SIG_SETMASK, &oldset, null);
             return;
         };
 
         // 增加抢占计数（在关中断状态下安全）
         schedule.preemption_count.raw += 1;
 
-        // 检查协程状态，确保它是正在运行的
-        if (co.state != .RUNNING) {
-            _ = c.sigprocmask(c.SIG_SETMASK, &oldset, null);
-            return;
-        }
-
-        const interrupted_ctx: *c.ucontext_t = @ptrCast(@alignCast(uctx_ptr.?));
-
-        // 完整保存被中断的上下文到协程
-        co.ctx = interrupted_ctx.*;
-
-        // 为signalHandler配置新的栈
-        const new_rip = @intFromPtr(&signalHandler);
-
-        // 使用协程的栈作为signalHandler的栈，确保16字节对齐
-        const stack_top = co.stack[co.stack.len - 1 ..].ptr;
-        const aligned_stack = @as(*u8, @ptrFromInt(@intFromPtr(stack_top) & ~@as(usize, 15)));
-
-        // 设置正确的调用栈
-        // 1. 将返回地址压入栈中（这里我们设置一个假的返回地址，因为signalHandler不会返回）
-        const fake_return_addr = @intFromPtr(&signalHandler) + 1000; // 假的返回地址
-
-        // 2. 为返回地址预留空间，并确保16字节对齐
-        const stack_ptr = @as(*u8, @ptrFromInt(@intFromPtr(aligned_stack) - 16)); // 预留16字节空间
-        const return_addr_ptr = @as(*usize, @ptrFromInt(@intFromPtr(stack_ptr) + 8)); // 在栈顶+8的位置放置返回地址
-        return_addr_ptr.* = fake_return_addr;
-
-        // 3. 设置栈指针和指令指针
-        const rsp_ptr = @as(*u8, @ptrFromInt(@intFromPtr(stack_ptr) + 8)); // RSP指向返回地址
-        interrupted_ctx.uc_mcontext.gregs[c.REG_RSP] = @intCast(@intFromPtr(rsp_ptr));
-        interrupted_ctx.uc_mcontext.gregs[c.REG_RIP] = @intCast(new_rip);
-
-        // 恢复信号屏蔽并返回
-        // 内核恢复执行时会跳转到 signalHandler
-        _ = c.sigprocmask(c.SIG_SETMASK, &oldset, null);
+        co.Resume() catch return;
+        co.Suspend() catch return;
     }
 
     const CoMap = std.AutoArrayHashMap(usize, *Co);