PAYATHON 2026

C 线程同步作业中使用 POSIX semaphores 时的 deadlock 如何排查?

排障赵师傅

死锁主要有两个原因:访问 p2_t_count 时没有同步,线程又在取得运行名额之前就决定是否进入“扣留”分支。这样一来,可能有过多线程提前进入该分支,随后等待只会释放 5 次的 sem_kidnap,导致部分线程永久阻塞。

修复时,应分别处理“选出需要等待线程 10 的 5 个线程”和“限制同时运行的线程数”,并让每个普通线程在输出 END 后归还自己取得的名额。

为什么释放 5 次之后仍然会死锁?

分支判断可能在等待期间失效

问题出在判断条件和等待许可的先后顺序:

if (p2_t_count < 5) {
    sem_wait(&sem_t2);
    /* ... */
    sem_wait(&sem_kidnap);
}

sem_t2 的初始值为 5,只能限制通过 sem_wait() 的线程数,无法限制提前通过外层 if 的线程数。

多个线程可能都先读到 p2_t_count < 5,进入分支后才阻塞在 sem_wait(&sem_t2)。取得许可后,它们不会重新判断条件,仍会继续执行后面的 sem_wait(&sem_kidnap)。

即使暂时假设计数更新没有丢失,也可能出现以下执行顺序:

  1. 10 个普通线程先后通过 if,其中 5 个取得 sem_t2 的许可,另外 5 个等待。
  2. 前 5 个线程输出 BEGIN,通知线程 10,然后等待 sem_kidnap。
  3. 线程 10 输出 END,释放这 5 个线程,并向 sem_t2 归还 5 个许可。
  4. 先前已经进入分支的另外 5 个线程取得许可,继续执行,最终也等待 sem_kidnap。
  5. 此时已经没有线程会再向 sem_kidnap 发放许可。

后一批线程占着全部运行名额,却无法结束,其余线程也就一直等在 sem_t2 上。

p2_t_count++ 本身也存在数据竞争

多个线程访问同一个普通 int,却没有使用互斥机制:

if (p2_t_count < 5)
p2_t_count++;
if (p2_t_count == 5)

这在 C 中构成数据竞争,行为未定义。因此,上面的执行顺序只能说明设计缺陷,不能涵盖实际程序可能出现的所有结果。

sem_t2 允许 5 个线程同时进入,不能保护计数器。将变量声明为 volatile 也无济于事。即使把递增改为原子操作,仍不能保证“检查是否不足 5 个,然后选入”这一整套操作不可分割。

线程 10 提前归还名额,还可能突破并发上限

线程 10 执行:

sem_post(&sem_kidnap);

这里只是允许某个等待线程继续执行,该线程未必已经输出 END。

如果线程 10 紧接着向 sem_t2 发放 5 个许可,新线程就可能输出 BEGIN,而原先的 5 个线程还没有输出 END。按照题目对“运行”的定义,此时可能有超过 6 个线程处于运行区间。因此,运行名额应由持有它的线程在自己的 END 之后归还。

如何调整同步逻辑?

可以将 sem_t2 的初始值保留为 5,为线程 10 单独预留第六个位置。线程 10 不获取 sem_t2。

普通线程统一按以下步骤执行:

  1. 获取 sem_t2,然后输出 BEGIN。
  2. 在互斥保护下,判断自己是否属于需要等待线程 10 的 5 个线程。
  3. 第五个被选中的线程通知线程 10;这 5 个线程等待线程 10 输出 END。
  4. 输出自己的 END,归还 sem_t2。

计数器记录已经选中的线程数,达到 5 后保持不变,不需要递减。

线程 10 原有的“一次 sem_post() 加两次 sem_wait()”,在调用均成功且没有其他访问者的前提下,净效果是等待一个外部许可,可以直接改为一次 sem_wait()。信号量会保留已经发出的许可,所以即使第五个线程先通知、线程 10 后等待,通知也不会丢失。

修改后的核心代码

保留原来的三个信号量名称,并增加初始值为 1 的 count_lock 来保护计数器。struct thread_arg、info()、BEGIN 和 END 沿用作业中的定义。

#include <errno.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>

static int p2_t_count = 0;

static sem_t sem_t2;
static sem_t sem_t210;
static sem_t sem_kidnap;
static sem_t count_lock;

static void init_sem(sem_t *sem, unsigned int value)
{
    if (sem_init(sem, 0, value) == -1) {
        perror("sem_init");
        exit(EXIT_FAILURE);
    }
}

static void wait_sem(sem_t *sem)
{
    while (sem_wait(sem) == -1) {
        if (errno == EINTR) {
            continue;
        }

        perror("sem_wait");
        exit(EXIT_FAILURE);
    }
}

static void post_sem(sem_t *sem)
{
    if (sem_post(sem) == -1) {
        perror("sem_post");
        exit(EXIT_FAILURE);
    }
}

static void init_sync(void)
{
    init_sem(&sem_t2, 5);
    init_sem(&sem_t210, 0);
    init_sem(&sem_kidnap, 0);
    init_sem(&count_lock, 1);
}

void *thread_barrier(void *arg)
{
    struct thread_arg *thread_info = arg;
    int held = 0;

    wait_sem(&sem_t2);

    info(BEGIN,
         thread_info->process_n,
         thread_info->thread_n);

    wait_sem(&count_lock);

    if (p2_t_count < 5) {
        held = 1;
        ++p2_t_count;

        if (p2_t_count == 5) {
            post_sem(&sem_t210);
        }
    }

    post_sem(&count_lock);

    if (held) {
        wait_sem(&sem_kidnap);
    }

    /* 普通线程需要执行的工作可放在 BEGIN 与 END 之间。 */

    info(END,
         thread_info->process_n,
         thread_info->thread_n);

    post_sem(&sem_t2);
    return NULL;
}

void *thread_t210(void *arg)
{
    (void)arg;

    info(BEGIN, 2, 10);

    wait_sem(&sem_t210);

    info(END, 2, 10);

    for (int i = 0; i < 5; ++i) {
        post_sem(&sem_kidnap);
    }

    return NULL;
}

必须在创建任何工作线程之前调用 init_sync()。40 个工作线程中,线程 10 使用 thread_t210,其余 39 个使用 thread_barrier。运行名额由普通线程各自归还,线程 10 不再向 sem_t2 批量归还许可。

这段代码为什么满足条件?

普通线程必须先取得 sem_t2 才能输出 BEGIN,并在输出 END 后归还许可,因此最多有 5 个普通线程处于运行区间。加上单独运行的线程 10,总数最多为 6。

前 5 个普通线程都会被选中,在输出 BEGIN 后等待 sem_kidnap。第五个线程发出通知时,这 5 个线程都已经输出 BEGIN,且都无法提前输出 END。

线程 10 收到通知后输出 END,此刻恰好有另外 5 个线程仍处于运行区间。随后,线程 10 发放 5 个释放许可,这些线程各自结束并归还名额,剩余线程便能继续取得名额,在结束后归还。

线程 10 结束后,这个方案仍然最多允许 5 个普通线程同时运行,符合“最多 6 个”的要求。如果后续阶段还需要充分使用 6 个名额,就要另行设计容量切换;本题没有这一要求。

主线程等待与排查注意事项

主线程应先创建全部 40 个工作线程,再逐个调用 pthread_join()。如果每创建一个线程就立即等待它结束,主线程可能在创建线程 10 之前,就已经等在某个被扣留的线程上。

假设 threads 保存了全部成功创建的 40 个线程:

for (int i = 0; i < 40; ++i) {
    int rc = pthread_join(threads[i], NULL);

    if (rc != 0) {
        fprintf(stderr, "pthread_join: %s\n", strerror(rc));
        exit(EXIT_FAILURE);
    }
}

这段代码还需要包含 <pthread.h> 和 <string.h>。调用 pthread_create() 与 pthread_join() 时都应检查返回值。这两个函数通过返回值报告错误,不应直接依赖 perror()。等所有线程结束后,再销毁信号量。

继续排查时,可以核对以下几点:

  • 每次取得运行名额后,是否都在自己的 END 之后归还一次。
  • 等待 sem_kidnap 的线程是否恰好只有 5 个。
  • 访问计数器的所有路径是否都使用同一个锁。
  • 是否在持有 count_lock 时等待其他事件。示例在等待 sem_kidnap 前已经释放该锁。
  • 输出记录是否能可靠反映调用顺序。如果 info() 本身不能保证并发输出完整,应先处理日志同步。

上述流程能够正常完成,前提是线程创建成功、没有线程中途取消或提前退出,并且线程最终能得到调度。sleep() 或调整创建顺序无法修复这些同步关系;日志中偶尔出现一次顺利结束,也不能证明原逻辑正确。

备注:内容仅供参考。