自定义线程实现中kthread_cancel触发SIGSEGV问题求助

你的核心问题在于：setjmp()/longjmp() 和 getcontext()/setcontext() 不支持跨线程操作。这些函数保存的是当前线程的栈上下文，当其他线程调用 longjmp 或 setcontext 时，会试图将当前线程的栈指针切换到目标线程的栈地址，直接导致栈结构混乱，触发 SIGSEGV（Valgrind 输出的 SP 异常也验证了这一点）。

要实现跨线程的取消功能，需要让目标线程在自己的上下文内完成上下文跳转，以下是两种可行方案：

方案一：基于信号的异步取消（模拟 pthread_cancel 异步行为） #

利用信号机制让目标线程在自身上下文内响应取消请求，具体步骤如下：

1. 扩展线程结构体 #

typedef struct kthread_task {
    jmp_buf thread_env;
    volatile int canceled;
    volatile int contexted;
    void* (*thread_func)(void*);
    void* thread_func_arg;
    void* return_value;
    pthread_t tid; // 保存系统线程ID，用于发送信号
} kthread_task_t;
typedef kthread_task_t* kthread_t;

2. 目标线程入口函数（设置跳转点） #

在目标线程自己的栈上设置 setjmp 跳转点，确保后续 longjmp 是在目标线程上下文执行：

static void* thread_entry(void* arg) {
    kthread_task_t* thread_task = (kthread_task_t*)arg;
    
    // 在当前线程栈上设置跳转点，非0返回值表示是从longjmp跳转过来的
    if (setjmp(thread_task->thread_env) != 0) {
        thread_task->return_value = (void*)KTHREAD_CANCELED;
        pthread_exit(thread_task->return_value);
    }
    
    thread_task->contexted = 1; // 标记跳转点已初始化完成
    
    // 正常执行任务逻辑
    if (!thread_task->canceled) {
        thread_task->return_value = thread_task->thread_func(thread_task->thread_func_arg);
    } else {
        thread_task->return_value = (void*)KTHREAD_CANCELED;
    }
    
    return thread_task->return_value;
}

3. 注册信号处理函数 #

让目标线程在自身上下文内处理取消信号，触发 longjmp：

// 需要实现一个全局/线程局部存储的函数，获取当前线程的task指针
static kthread_task_t* get_current_thread_task(void);

static void cancel_signal_handler(int sig) {
    kthread_task_t* thread_task = get_current_thread_task();
    longjmp(thread_task->thread_env, 1); // 在目标线程上下文内跳转
}

4. kthread_cancel 实现 #

不再直接调用 longjmp，而是给目标线程发送信号：

int kthread_cancel(kthread_t thread) {
    // 等待跳转点初始化完成
    while (!thread->contexted) {
        usleep(1000); // 用usleep减少等待延迟
    }
    
    thread->canceled = 1;
    // 向目标线程发送自定义取消信号
    return pthread_kill(thread->tid, SIGUSR1);
}

5. 线程创建时的信号初始化 #

确保目标线程注册了信号处理函数：

int kthread_create(kthread_t* thread, void* (*func)(void*), void* arg) {
    *thread = malloc(sizeof(kthread_task_t));
    if (!*thread) return KTHREAD_FAILURE;
    
    (*thread)->thread_func = func;
    (*thread)->thread_func_arg = arg;
    (*thread)->canceled = 0;
    (*thread)->contexted = 0;
    
    // 注册信号处理（也可以在thread_entry内注册）
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = cancel_signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    
    sigaction(SIGUSR1, &sa, NULL);
    
    if (pthread_create(&(*thread)->tid, NULL, thread_entry, *thread) != 0) {
        free(*thread);
        return KTHREAD_FAILURE;
    }
    
    return KTHREAD_SUCCESS;
}

方案二：同步取消（目标线程主动检查） #

如果不需要异步打断线程执行，可采用更安全的同步取消模式：

1. kthread_cancel 仅设置取消标志
2. 目标线程在任务执行过程中定期检查标志，主动退出

示例代码 #

// 目标任务函数需主动检查取消标志
void* my_task(void* arg) {
    kthread_task_t* task = (kthread_task_t*)arg;
    while (1) {
        // 定期检查取消标志
        if (task->canceled) {
            return (void*)KTHREAD_CANCELED;
        }
        // 执行具体任务逻辑
        do_some_work();
    }
}

// kthread_cancel 简化实现
int kthread_cancel(kthread_t thread) {
    thread->canceled = 1;
    return KTHREAD_SUCCESS;
}

关键注意事项 #

• 禁止跨线程调用 longjmp/setcontext：这些函数仅能在保存上下文的线程内使用。
• 信号处理函数必须异步安全：longjmp 属于异步安全函数，但处理函数内不能调用非异步安全的API（如printf、malloc）。
• 用 volatile 修饰取消标志：避免编译器优化导致线程读取到旧的标志值。

内容的提问来源于stack exchange，提问作者innovat1on_