操作系统 / 系统课时

处理优先级反转与继承协议

处理优先级反转与继承协议

高优先级线程被低优先级线程持有的锁挡住时,中优先级线程可能持续抢占低优先级线程,反而让最高优先级任务等待更久。本节用三个 SCHED_FIFO 线程复现这种反转,并用 PTHREAD_PRIO_INHERIT 验证锁持有者临时继承高优先级后的改善。

学习目标

  • 解释高、中、低三个优先级线程如何形成经典优先级反转。
  • 用同一组锁竞争实验比较普通互斥量与优先级继承互斥量。
  • 识别优先级继承能解决的调度问题,以及它无法替代的临界区治理。

反转发生在锁依赖与抢占叠加时

设低优先级线程 L 先拿到互斥量,高优先级线程 H 随后请求同一把锁并阻塞。此时 L 本应尽快运行并释放锁,但中优先级线程 M 不需要这把锁,却可以抢占 L;结果是 H 间接被 M 延迟,实际执行次序违背了优先级意图。

优先级继承把这条依赖显式传给调度器:当 H 阻塞在启用了 PTHREAD_PRIO_INHERIT 的互斥量上时,持锁的 L 临时按更高优先级运行,直到释放相关锁。这样 M 就不能在关键窗口持续抢占 L。

普通互斥量与优先级继承的时序对比

构造可重复的竞争实验

为了让现象稳定出现,三个线程都使用 SCHED_FIFO 并固定到同一个可用 CPU:L 的优先级为 20,M 为 50,H 为 80。L 执行 250 ms 的 CPU 工作并持锁;H 在 50 ms 后请求锁;M 在 80 ms 后执行 600 ms 的 CPU 工作。

实时调度策略通常需要 root 或 CAP_SYS_NICE。请只在测试机上运行,因为错误的 SCHED_FIFO 程序可能长期占用 CPU。下面程序会自动选择当前进程允许集合中的第一个 CPU,避免硬编码 CPU 编号。

c
#define _GNU_SOURCE
#include <errno.h>
#include <pthread.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

static pthread_mutex_t lock;
static pthread_barrier_t start_barrier;
static int target_cpu;
static double high_wait_ms;
static double low_unlock_ms;
static double medium_finish_ms;
static struct timespec wall_start;

static double diff_ms(struct timespec a, struct timespec b) {
    return (b.tv_sec - a.tv_sec) * 1000.0 +
           (b.tv_nsec - a.tv_nsec) / 1000000.0;
}

static double since_start_ms(void) {
    struct timespec now;
    clock_gettime(CLOCK_MONOTONIC, &now);
    return diff_ms(wall_start, now);
}

static void burn_cpu_ms(long ms) {
    struct timespec begin, now;
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &begin);
    do {
        clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);
    } while (diff_ms(begin, now) < (double)ms);
}

static void *low_thread(void *arg) {
    (void)arg;
    pthread_barrier_wait(&start_barrier);

    pthread_mutex_lock(&lock);
    burn_cpu_ms(250);
    low_unlock_ms = since_start_ms();
    pthread_mutex_unlock(&lock);

    return NULL;
}

static void *high_thread(void *arg) {
    (void)arg;
    pthread_barrier_wait(&start_barrier);
    usleep(50 * 1000);

    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC, &begin);
    pthread_mutex_lock(&lock);
    clock_gettime(CLOCK_MONOTONIC, &end);

    high_wait_ms = diff_ms(begin, end);
    pthread_mutex_unlock(&lock);
    return NULL;
}

static void *medium_thread(void *arg) {
    (void)arg;
    pthread_barrier_wait(&start_barrier);
    usleep(80 * 1000);

    burn_cpu_ms(600);
    medium_finish_ms = since_start_ms();
    return NULL;
}

static pthread_t spawn(void *(*fn)(void *), int priority) {
    pthread_t thread;
    pthread_attr_t attr;
    struct sched_param param = {.sched_priority = priority};
    cpu_set_t set;

    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
    pthread_attr_setschedparam(&attr, &param);

    CPU_ZERO(&set);
    CPU_SET(target_cpu, &set);
    pthread_attr_setaffinity_np(&attr, sizeof(set), &set);

    int rc = pthread_create(&thread, &attr, fn, NULL);
    pthread_attr_destroy(&attr);
    if (rc != 0) {
        fprintf(stderr, "pthread_create: %s\n", strerror(rc));
        exit(EXIT_FAILURE);
    }
    return thread;
}

int main(int argc, char **argv) {
    if (argc != 2 ||
        (strcmp(argv[1], "none") != 0 &&
         strcmp(argv[1], "inherit") != 0)) {
        fprintf(stderr, "usage: %s none|inherit\n", argv[0]);
        return EXIT_FAILURE;
    }

    cpu_set_t allowed;
    CPU_ZERO(&allowed);
    if (sched_getaffinity(0, sizeof(allowed), &allowed) != 0) {
        perror("sched_getaffinity");
        return EXIT_FAILURE;
    }

    target_cpu = -1;
    for (int cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
        if (CPU_ISSET(cpu, &allowed)) {
            target_cpu = cpu;
            break;
        }
    }
    if (target_cpu < 0) {
        fprintf(stderr, "no allowed CPU\n");
        return EXIT_FAILURE;
    }

    pthread_mutexattr_t mutex_attr;
    pthread_mutexattr_init(&mutex_attr);
    int protocol = strcmp(argv[1], "inherit") == 0
        ? PTHREAD_PRIO_INHERIT
        : PTHREAD_PRIO_NONE;

    int rc = pthread_mutexattr_setprotocol(&mutex_attr, protocol);
    if (rc != 0) {
        fprintf(stderr, "setprotocol: %s\n", strerror(rc));
        return EXIT_FAILURE;
    }
    pthread_mutex_init(&lock, &mutex_attr);
    pthread_mutexattr_destroy(&mutex_attr);

    pthread_barrier_init(&start_barrier, NULL, 4);

    pthread_t low = spawn(low_thread, 20);
    pthread_t high = spawn(high_thread, 80);
    pthread_t medium = spawn(medium_thread, 50);

    clock_gettime(CLOCK_MONOTONIC, &wall_start);
    pthread_barrier_wait(&start_barrier);

    pthread_join(low, NULL);
    pthread_join(high, NULL);
    pthread_join(medium, NULL);

    printf("mode=%s cpu=%d high_wait_ms=%.1f "
           "low_unlock_ms=%.1f medium_finish_ms=%.1f\n",
           argv[1], target_cpu, high_wait_ms,
           low_unlock_ms, medium_finish_ms);

    pthread_barrier_destroy(&start_barrier);
    pthread_mutex_destroy(&lock);
    return EXIT_SUCCESS;
}

保存为 prio_inversion.c,编译后分别运行普通互斥量和优先级继承互斥量。

bash
gcc -O2 -pthread prio_inversion.c -o prio_inversion
sudo ./prio_inversion none
sudo ./prio_inversion inherit

预期输出

text
mode=none cpu=<CPU> high_wait_ms=<TIME> low_unlock_ms=<TIME> medium_finish_ms=<TIME>
mode=inherit cpu=<CPU> high_wait_ms=<TIME> low_unlock_ms=<TIME> medium_finish_ms=<TIME>

<CPU> 是程序自动选出的允许 CPU,<TIME> 会随主机负载变化。验证重点不是某个固定毫秒数,而是 inherit 模式下的 high_wait_ms 应明显小于 none:普通互斥量中 M 会抢占 L,而继承协议让持锁的 L 在 H 等待期间临时获得足够高的调度优先级。

继承协议只缩短调度型阻塞

PTHREAD_PRIO_INHERIT 解决的是“高优先级等待持锁者,而持锁者又被无关的中优先级工作抢占”这一类阻塞。它不会让临界区本身变短,也不会修复死锁、锁顺序错误或持锁期间的慢 I/O;如果 L 在锁内等待磁盘、网络或另一条未受控依赖,H 仍然会被一起拖住。

优先级继承还可能沿 PI 互斥量依赖链继续传播,但这不是放宽锁设计的理由。实时路径仍应保持临界区短小、避免在持锁时执行不可预测操作,并限制共享锁的数量。

选择协议时看最坏等待而不是平均吞吐

普通 PTHREAD_PRIO_NONE 互斥量开销更直接,适合没有严格优先级保证的常规线程。PTHREAD_PRIO_INHERIT 适合实时线程之间确实存在锁共享,而且必须限制高优先级线程被较低优先级线程间接拖延的场景。

另一类协议 PTHREAD_PRIO_PROTECT 使用优先级上限:线程拿锁后按预设 ceiling 运行,依赖更强的系统设计与上限配置。无论使用哪种协议,都应先从最坏阻塞时间、锁依赖关系和调度策略出发,而不是仅凭平均延迟决定。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

处理优先级反转与继承协议

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通