- 每一块 = 老师 PDF 的一页,标题旁蓝色胶囊是页码;每块开头可展开原页截图,插图页默认展开。
- 正文是逐句对照:蓝灰色衬线字是西语原句,下面带「中」标签的是逐句翻译,一句不漏。
- 句子后面紧跟「考点 / 陷阱 / 记忆钩子」,告诉你这句在专业课笔试和 SIELE 式西语答题里怎么用。
- 带虚下划线的西语词,鼠标悬停显示中文;代码高亮行、轨迹表红底行是必考重点。
- 打印时自动隐藏导航、指南与截图,一页一块不切断。
一、Regiones críticas:为什么信号量还不够
p.1–p.7Portada · 封面
▸ 原页截图 p.1

Sistemas Concurrentes y de Tiempo Real
并发与实时系统(课程名)。
Grado en Ingeniería Telemática
远程通信工程本科(你所在的学位)。
Tema 3: Comunicación y sincronización con memoria compartida. Parte 3. Spinlock y Mutex
主题 3:共享内存下的通信与同步。第 3 部分:自旋锁与互斥量。
Índice de contenidos · 目录
▸ 原页截图 p.2

Índice de contenidos
目录。
Regiones críticas
临界区(语言层面的「保护区」抽象)。
Spinlocks
自旋锁(拿不到就原地空转等)。
Mutex
互斥量(拿不到就睡,让出 CPU)。
Regiones críticas condicionales
条件临界区(带 when (B) 守卫的临界区)。
Variables condición
条件变量(POSIX 里真正实现「条件临界区」的工具)。
Monitores
管程(一种把同步全部封装起来的编程「哲学」)。
Regiones críticas · 信号量的四宗罪
▸ 原页截图 p.3

Críticas a los semáforos
对信号量的批评(本节标题)。
Son primitivas de muy bajo nivel, eficientes desde el punto de vista de la implementación, pero no adecuadas cuando hay que resolver problemas de sincronización complejos (lectores/escritores).
它们是非常底层的原语,从实现角度看很高效,但不适合用来解决复杂的同步问题(比如读者/写者)。
A veces, los semáforos están sobrecargados (se utilizan para más de una tarea: exclusión mutua y sincronización).
有时信号量会超载——同一个信号量被拿来做不止一件事(既做互斥、又做同步)。
Esto hace que sea difícil entender la interacción entre los procesos/hebras que los utilizan, lo que dificulta la modificación del código.
这就导致很难看懂使用它的进程/线程之间到底怎么交互,进而很难改代码。
Errores pequeños pueden tener consecuencias impredecibles:
小错误会带来不可预测的后果:
Olvidar una operación wait en un pre-protocolo puede violar la exclusión mutua;
前协议里漏写一个 wait,就可能破坏互斥;
Olvidar una operación post en un post-protocolo puede producir bloqueos.
后协议里漏写一个 post,就可能造成阻塞(永久卡死)。
① muy bajo nivel(太底层,复杂场景不适用);
② sobrecargados(一物多用,可读性差);
③ errores pequeños → consecuencias impredecibles(少一个 wait 破坏互斥,少一个 post 造成死锁)。
最后这一对「漏 wait = 破互斥 / 漏 post = 死锁」是本页最可能被单独考的一句话。
Regiones críticas · 定义
▸ 原页截图 p.4

Una región crítica es una secuencia de instrucciones en una hebra, que accede a un recurso compartido, y que, por definición se ejecuta en exclusión mutua.
El lenguaje lo asegura porque pone automáticamente (de forma transparente al programador) los medios necesarios para asegurar la exclusión mutua.
语言本身来保证这一点:它自动(对程序员透明地)提供确保互斥所需的手段。
① secuencia de instrucciones(是一段代码,不是一条指令);
② en una hebra(属于某一个线程);
③ accede a un recurso compartido 且 por definición en exclusión mutua(访问共享资源,且天生互斥)。
最关键的一句是 «de forma transparente al programador»——互斥由语言自动保证,程序员不用手写 wait/post。这句话就是「为什么要有临界区」的标准答案。
Regiones críticas · region(mutex){ S; } 伪代码
▸ 原页截图 p.5

Para definir una región crítica necesitamos utilizar algún mecanismo de nuestro lenguaje que nos permita indicar qué secuencia de instrucciones corresponden a una región crítica.
要定义一个临界区,我们需要用语言提供的某种机制,来标记出哪一段指令属于临界区。
Vamos a suponer que tenemos una palabra clave “region”
我们假设存在一个关键字 region。
region (mutex) {
S;
}
Regiones críticas · 进入 / 排队 / 释放 三步
▸ 原页截图 p.6

Cualquier hebra que quiera ejecutar S debe usar algún mecanismo que “active” una zona de exclusión mutua
任何想执行 S 的线程,都必须使用某种机制来「激活」一块互斥区。
Si no puede porque otra hebra tiene adquirida esa zona de exclusión, se bloquea en una cola asociada a ese mecanismo
如果它做不到——因为另一个线程已经占用了那块互斥区——它就在与该机制关联的队列中阻塞。
Cuando la hebra que tiene el acceso a la zona de exclusión mutua termina su acceso, la libera permitiendo entrar a la primera hebra de las que están en la cola de espera
当持有互斥区访问权的线程结束访问时,它释放该区,让等待队列中的第一个线程进入。
region (mutex){ S; } // 语义展开: pido bloquear(mutex) // ① 申请加锁 Ejecuto S // ② 执行临界区 devuelvo bloqueo(mutex) // ③ 释放锁 // 拿不到锁 → 进入「挂起线程队列」等待 mutex
pido bloquear ↔ wait(mutex)
devuelvo bloqueo ↔ post(mutex)
考试常问「临界区的进入协议等价于信号量的哪几步」,答案就是这个对应关系。
① 拿不到锁时线程是 se bloquea(阻塞),不是忙等——这是 region 相对 spinlock 的关键区别;
② 释放后唤醒的是队列里的 la primera(第一个),这是 FIFO 语义,直接关系到后面讲的「公平性」。
Regiones críticas · 同名的才互斥 + POSIX 的两个真家伙
▸ 原页截图 p.7

Sólo las regiones críticas etiquetadas con el mismo identificador se ejecutan en exclusión mutua, por ejemplo, pueden solaparse en el tiempo.
只有标了相同标识符的临界区之间才互斥;标识符不同的临界区(如下图所示)在时间上可以重叠执行。
region (mutex) { S1; } region (mutex2) { S2; } // S1 与 S2 用的是不同的锁 ⇒ 二者可以同时执行,不互斥
¿Qué mecanismos reales tenemos en POSIX?
在 POSIX 里,我们实际能用的机制有哪些?
Mutex
互斥量。
Spinlock
自旋锁。
① 互斥的粒度由「锁的名字」决定——同名互斥,异名并行。这就是为什么真实代码里要精心设计「哪段代码用哪把锁」,也是后面读者/写者能用 mutex 保护计数器、又用 cond 等条件的理论基础。
② POSIX 里对应 region(mutex){S;} 的真实机制只有两个:Mutex 和 Spinlock。这句话是简答题的送分点。
二、Spinlocks:原地空转的轻量锁
p.8–p.12Spinlocks · 定义、代价、优点与适用场景
▸ 原页截图 p.8

Spinlocks
自旋锁。
Los Spinlocks son un mecanismo de sincronización ligero y de bajo nivel
自旋锁是一种轻量级、底层的同步机制。
Cuando una hebra intenta toma un spinlock y éste ya está tomado por otra hebra, tendrá que esperar hasta que se quede libre
当一个线程试图获取自旋锁、而该锁已被另一个线程占用时,它必须一直等到锁变空为止。
La hebra permanece activa consumiendo CPU en un bucle
该线程保持活跃,在循环中持续消耗 CPU(这就是「自旋」的字面意思)。
El lock, debe mantenerse un corto espacio de tiempo
锁只能被持有很短的一段时间。
Porque las otras hebras están esperando activamente
因为其他线程正在主动地(而不是挂起地)等待。
Ventajas con respecto a otros mecanismos
相对于其他机制的优点:
Menor sobrecoste al evitar bloquear y despertar, respuesta rápida en sistemas multinúcleo, evitan cambios de contexto
额外开销更小——省掉了「阻塞 + 唤醒」这一套;在多核系统中响应快;避免上下文切换。
Más apropiados para secciones críticas muy breves, varios núcleos y espera predecible
更适用于:极短的临界区、多核、以及可预测的等待。
En otros casos es mejor usar mutex (siguiente mecanismo)
其他情况下,最好改用 mutex(下一个机制)。
| 对比项 | Spinlock | Mutex |
|---|---|---|
| 拿不到锁时 | while(locked); | 挂起(阻塞)线程 |
| CPU 消耗 | 一直占着 CPU 空转 | 让出 CPU,不耗 |
| 唤醒开销 | 无(本来就没睡) | 有(系统调用 + 上下文切换) |
| 适合的临界区 | 极短(几条指令) | 长、或时长不可预测 |
| 单核上 | 几乎没意义(转着也进不去) | 正常 |
Spinlocks · 四个 POSIX 函数
▸ 原页截图 p.9

Spinlocks
自旋锁。
Funciones POSIX:
POSIX 函数:
int pthread_spin_init(pthread_spinlock_t *lock, int pshared); int pthread_spin_lock(pthread_spinlock_t *lock); int pthread_spin_trylock(pthread_spinlock_t *lock); int pthread_spin_unlock(pthread_spinlock_t *lock);
| 函数 | 作用 | 拿不到锁时 |
|---|---|---|
| pthread_spin_init | 初始化,pshared 决定进程内/进程间共享 | — |
| pthread_spin_lock | 加锁 | 原地自旋,直到成功 |
| pthread_spin_trylock | 试加锁,不等待 | 立即返回 EBUSY |
| pthread_spin_unlock | 解锁 | — |
Ejemplo spinlock · 两个线程抢一个 contador
▸ 原页截图 p.10

int contador = 0; pthread_spinlock_t lock; void *incrementar(void *arg) { for (int i = 0; i < N; i++) { // Adquirir el spinlock pthread_spin_lock(&lock); // Sección crítica contador++; // Liberar el spinlock pthread_spin_unlock(&lock); } return NULL; } int main(void) { pthread_t t1, t2; // Inicializar el spinlock if (pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE) != 0) { fprintf(stderr, "Error al inicializar el spinlock\n"); return EXIT_FAILURE; } pthread_create(&t1, NULL, incrementar, NULL); pthread_create(&t2, NULL, incrementar, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); printf("Valor final del contador: %d\n", contador); // Destruir el spinlock pthread_spin_destroy(&lock); return EXIT_SUCCESS; }
// Adquirir el spinlock
// 获取自旋锁
// Sección crítica
// 临界区
// Liberar el spinlock
// 释放自旋锁
// Inicializar el spinlock
// 初始化自旋锁
Error al inicializar el spinlock
初始化自旋锁失败(错误提示字符串)。
Valor final del contador: %d
计数器的最终值:%d
// Destruir el spinlock
// 销毁自旋锁
Productor-consumidor con spinlock · main 与共享变量
▸ 原页截图 p.11

#define TAM_BUFFER 5 pthread_spinlock_t lock; int buffer[TAM_BUFFER]; int nelem = 0; // Número de elementos en el búfer int main(void) { pthread_t p, c; if (pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE) != 0) { fprintf(stderr, "Error al inicializar el spinlock\n"); return EXIT_FAILURE; } if (pthread_create(&p, NULL, productor, NULL) != 0 || pthread_create(&c, NULL, consumidor, NULL) != 0) { fprintf(stderr, "Error al crear las hebras\n"); return EXIT_FAILURE; } pthread_join(p, NULL); pthread_join(c, NULL); pthread_spin_destroy(&lock); return EXIT_SUCCESS; }
Productor-consumidor con spinlock
用自旋锁实现的生产者—消费者。
#define TAM_BUFFER 5
定义缓冲区容量为 5(环形缓冲区的大小)。
// Número de elementos en el búfer
// 缓冲区中当前的元素个数——这是最关键的共享变量。
Error al crear las hebras
创建线程失败(错误提示字符串)。
| 全局变量 | 作用 | 谁写它 |
|---|---|---|
| lock | 唯一的一把自旋锁 | — |
| buffer[5] | 环形存放数据 | productor 写 / consumidor 读 |
| nelem | 当前元素数,0…5 | 两者都改(++ / --) |
| p / c | 下标指针(在函数内,见 p.12) | 各自私有 |
Productor / consumidor · 锁 + if 的「假同步」
▸ 原页截图 p.12

void *productor(void *arg) { int i = 0; int p = 0; // Próxima posición donde producir while (1) { pthread_spin_lock(&lock); if (nelem < TAM_BUFFER) { buffer[p] = i; printf("Productor: %d\n", i); p = (p + 1) % TAM_BUFFER; nelem++; i++; } pthread_spin_unlock(&lock); } } void *consumidor(void *arg) { int c = 0; // Próxima posición donde consumir while (1) { pthread_spin_lock(&lock); if (nelem > 0) { int dato = buffer[c]; printf("Consumidor: %d\n", dato); c = (c + 1) % TAM_BUFFER; nelem--; } pthread_spin_unlock(&lock); } return NULL; }
// Próxima posición donde producir
// 下一个要写入(生产)的位置。
if (nelem < TAM_BUFFER)
如果缓冲区还没满——只有这时才写。
p = (p + 1) % TAM_BUFFER;
下标环形回绕:走到末尾就回到 0。
// Próxima posición donde consumir
// 下一个要读取(消费)的位置。
if (nelem > 0)
如果缓冲区非空——只有这时才读。
Productor: %d / Consumidor: %d
生产者:%d / 消费者:%d(输出格式串)。
① 为什么用 if 而不是 while?因为这里「等待」不是发生在条件判断处,而是靠外层 while(1) 反复重试;换言之 if 只是「这一次跳过」。
② 锁保护了什么?保护了 nelem 和 buffer 的一致性(读-改-写不被撕裂),但没有提供「等到条件成立」的能力。
三、Mutex:拿不到就睡觉的锁
p.13–p.18Mutex · 定义、阻塞、以及「谁锁谁解」
▸ 原页截图 p.13

Mutex
互斥量。
Los mutex (mutual exclusion) son un mecanismo de sincronización que permite garantizar el acceso exclusivo a recursos compartidos
mutex(mutual exclusion,互斥)是一种同步机制,用来保证对共享资源的独占访问。
Cuando una hebra intenta adquirir un mutex que ya está adquirido por otra hebra, queda bloqueada hasta que el mutex se libera
当一个线程试图获取已被别的线程持有的 mutex 时,它会阻塞,直到该 mutex 被释放。
La hebra bloqueada deja de ejecutarse y cede la CPU a otras hebras
被阻塞的线程停止执行,并把 CPU 让给其他线程。
Solo la hebra que adquirió el mutex debe liberarlo (a diferencia de un semáforo)
只有获取了 mutex 的那个线程才能释放它(这一点与信号量不同)。
Son adecuados cuando la espera puede ser larga o impredecible, sin malgastar CPU
适用于等待时间可能很长或不可预测的场合,且不浪费 CPU。
| 机制 | 拿不到时 | 谁能解锁 | 浪费 CPU |
|---|---|---|---|
| Spinlock | 原地自旋 | 任何线程(POSIX 不强制) | 会 |
| Mutex | 阻塞并让出 CPU | sólo quien lo adquirió | 不会 |
| Semáforo | 阻塞(P 操作) | 任何线程都能 V(不限于持有者) | 不会 |
① mutex 保证 acceso exclusivo(独占访问);
② 拿不到时是 queda bloqueada + cede la CPU——与 spinlock 的 consume CPU 正好相反,这是最经典的对比题;
③ 只有加锁者能解锁,a diferencia de un semáforo——括号里这句是命题人埋的送分点,几乎必考。
Mutex · 初始化与销毁(含 INITIALIZER 快捷方式)
▸ 原页截图 p.14

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); int pthread_mutex_destroy(pthread_mutex_t *mutex);
Mutex - Inicialización
Mutex —— 初始化。
Si attr es NULL, será un mutex con atributos por defecto
如果 attr 是 NULL,就是一个使用默认属性的 mutex。
El mutex se inicializa desbloqueado
mutex 初始化后处于未加锁(解锁)状态。
Para poder destruir un mutex debe estar desbloqueado
要销毁一个 mutex,它必须处于未加锁状态。
Alternativamente:
另一种写法(静态初始化):
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
① attr == NULL ⇒ 默认属性;
② 初始化后是 desbloqueado(不是「已锁」);
③ 销毁前必须解锁——销毁一把还锁着的 mutex 是未定义行为。
另外,PTHREAD_MUTEX_INITIALIZER 只能用于全局 / 静态变量,等价于「用默认属性 init 一次」,省掉显式 pthread_mutex_init 调用。
Mutex · 属性对象:类型、pshared、实时相关
▸ 原页截图 p.15

int pthread_mutexattr_init(pthread_mutexattr_t *attr); int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
Mutex
互斥量。
Varios atributos opcionales:
若干可选属性:
Tipo de mutex: PTHREAD_MUTEX_NORMAL, PTHREAD_MUTEX_ERRORCHECK, PTHREAD_MUTEX_RECURSIVE, PTHREAD_MUTEX_DEFAULT
mutex 的类型:NORMAL / ERRORCHECK / RECURSIVE / DEFAULT 四种。
Ejemplo: pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
示例:把属性对象的类型设为递归锁。
Protocolo y prioceiling: relacionados con el tiempo real (en temas posteriores)
协议与优先级上限(protocol / prioceiling):与实时相关,在后面章节讲。
Process-shared: Especifica si las hebras comparten el mutex
进程共享:指定这些线程是否共享该 mutex(即可否跨进程)。
Ejemplo: pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
示例:设为跨进程共享。
| 类型 | 行为 | 典型用途 |
|---|---|---|
| NORMAL | 重复加锁 → 死锁;解锁他人持有 → 未定义 | 性能优先,自己保证正确 |
| ERRORCHECK | 重复加锁返回错误;解锁非自己持有返回错误 | 调试、查错 |
| RECURSIVE | 同一线程可重复加锁,需同样次数解锁 | 递归函数里加锁 |
| DEFAULT | 实现相关的默认行为 | 不关心时用 |
Mutex · lock / trylock / unlock 与两类解锁错误
▸ 原页截图 p.16

int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex);
Al intentar desbloquear se pueden devolver dos tipos de errores:
尝试解锁时可能返回两类错误:
Si el mutex ya está desbloqueado
① 该 mutex 本来就是未加锁的(重复解锁)。
Si está tomado por otra hebra
② 它被另一个线程持有(你无权解)。
pthread_mutex_trylock intenta tomar un mutex. Si ya está bloqueado se devuelve un código de error EBUSY
pthread_mutex_trylock 尝试获取 mutex;如果已被锁住,就返回错误码 EBUSY。
Puede ser útil para evitar condiciones de deadlock
它可以用来避免死锁。
Nunca usar pthread_mutex_unlock en una hebra si previamente no se ha hecho pthread_mutex_lock en la misma hebra
绝对不要在一个线程里执行 unlock,除非该线程之前自己做过 lock。
| 调用 | 锁空闲 | 锁被别人持有 | 锁被自己持有 |
|---|---|---|---|
| lock | 取得锁,继续 | 阻塞等待 | NORMAL 型 ⇒ 死锁 |
| trylock | 取得锁,返回 0 | 返回 EBUSY | 多半返回错误/死锁 |
| unlock | 错误(已解锁) | 错误(非持有者) | 正常释放 |
Mutex 实例 · el problema de los jardines(main)
▸ 原页截图 p.17

#include <pthread.h> #include <stdio.h> //Variable global long Visitantes = 0; pthread_mutex_t mutex; int main () { pthread_t th1, th2, th3, th4; pthread_attr_t attr; long visi1 = 1000000; long visi2 = 2000000; pthread_attr_init(&attr); pthread_mutex_init(&mutex, NULL); pthread_create(&th1, &attr, HebraVisitas, &visi1); pthread_create(&th2, &attr, HebraVisitas, &visi2); pthread_create(&th3, &attr, HebraVisitas, &visi2); pthread_create(&th4, &attr, HebraVisitas, &visi2); pthread_join(th1, NULL); pthread_join(th2, NULL); pthread_join(th3, NULL); pthread_join(th4, NULL); printf("El numero de visitas totales=%ld\n", Visitantes); printf("Fin\n"); return 0; }
Mutex: el problema de los jardines
Mutex:花园问题(多个入口统计游客总数)。
//Variable global
// 全局变量。
El numero de visitas totales=%ld
游客总数 = %ld(long 用 %ld)。
Fin
结束。
| 线程 | 入口参数 | 要加多少次 |
|---|---|---|
| th1 | &visi1 = 1000000 | 1,000,000 |
| th2 | &visi2 = 2000000 | 2000000 |
| th3 | &visi2 = 2000000 | 2000000 |
| th4 | &visi2 = 2000000 | 2000000 |
| 合计 | 7,000,000 | |
另外函数名 HebraVisitas 里的 Hebra = 线程,是西语教材的固定用法。
Mutex 实例 · IncVsitantes 与 HebraVisitas
▸ 原页截图 p.18

void IncVsitantes() { pthread_mutex_lock(&mutex); Visitantes = Visitantes + 1; pthread_mutex_unlock(&mutex); } void *HebraVisitas(void *argg) { int i = 0; long *NumVisitas; NumVisitas = (long *) argg; for (i = 0; i < *NumVisitas; i++) { IncVsitantes(); } }
Mutex: el problema de los jardines
Mutex:花园问题(续)。
另外 HebraVisitas 声明为 void * 却没有 return——同样是讲义省略,编译器会警告。
四、Regiones críticas condicionales(RCC)
p.19–p.21RCC · mutex 不够用:隐式的忙等
▸ 原页截图 p.19

Regiones críticas condicionales
条件临界区(RCC)。
Mal utilizada, una región crítica puede dar lugar a una “espera activa implícita”
如果使用不当,临界区可能导致一种「隐式忙等」(espera activa implícita)。
Además de la exclusión mutua, una primitiva de sincronización debería ser capaz de resolver también condiciones de sincronización como las del problema del productor/consumidor
除了互斥之外,一个同步原语还应当能解决同步条件——就像生产者/消费者问题里的那些条件。
Para ello, extendemos las regiones críticas con variables condición y guardas, que deben evaluarse a true antes de que una hebra pueda hacerse con el recurso compartido
为此,我们用条件变量和守卫(guardas)来扩展临界区;守卫必须求值为 true,线程才能取得共享资源。
region (v) when (B) { S; } // pseudocódigo
| 概念 | 西语 | 作用 |
|---|---|---|
| 互斥 | exclusión mutua | 同一时刻只有一个线程在区内 |
| 同步条件 | condición de sincronización | 还要「等到条件成立」才能进 |
| 守卫 | guarda / B | 布尔表达式,必须先为真 |
| 条件变量 | variable condición | 存放「在这个条件上睡觉」的线程 |
RCC · 六步执行流程(进队 → 评估 → 睡 v)
▸ 原页截图 p.20

Una hebra que quiere ejecutar una RCC debe
一个想执行 RCC 的线程必须:
Conseguir el mutex del recurso compartido. Si no está disponible, la hebra se bloquea en la cola de entrada asociada al recurso
取得共享资源的 mutex;如果锁不可用,该线程就在与资源关联的入口队列(cola de entrada)中阻塞。
Cuando la hebra tiene el mutex, evalúa la expresión booleana B
当线程持有 mutex 时,它求值布尔表达式 B。
Si es cierta, ejecuta S
若为真,执行 S。
Si es falsa, libera el mutex y se bloquea en la cola de entrada asociada a v
若为假,释放 mutex,并在与 v 关联的入口队列中阻塞。
Una hebra que sale de una RCC libera el mutex del recurso
离开 RCC 的线程会释放资源的 mutex。
Se debe habilitar algún otro mecanismo para despertar a las hebras dormidas en v
必须另外提供某种机制,去唤醒睡在 v 上的线程。
region (mutex,v) when (B) { S; } // pseudocódigo
特别注意第 ④ 步的顺序:先释放 mutex,再阻塞——否则睡着时还占着锁,别人永远进不来,直接死锁。
RCC · Productor / Consumidor 伪代码
▸ 原页截图 p.21

void *Productor (void *arg) { while (1){ produce(aux); region (mutex, v) when (elem < N){ buffer[i] = aux; i = (i + 1) % N; elem++; } } …. } void *Consumidor(void *arg) while (1){ region (mutex, v) when (elem > 0){ int aux = buffer[i]; i = (i + 1) % N; elem--; } consume(aux); } } // pseudocódigo
Pseudocodigo
伪代码。
produce(aux) / consume(aux)
生产一个数据 / 消费一个数据(抽象操作)。
region (mutex, v) when (elem<N)
条件临界区:当缓冲区未满时才进入——不满足就自动睡到 v 上。
region (mutex, v) when (elem>0)
条件临界区:当缓冲区非空时才进入。
· spinlock 版:lock(); if (cond) {...} unlock(); ⇒ 不满足就转圈重试(忙等)
· RCC 版:region(mutex,v) when (cond) {...} ⇒ 不满足就睡觉(阻塞)
这就是本章从「锁」走向「条件变量」的核心动机,简答题必写这一句。
① 生产者与消费者共用同一个下标变量 i——真实代码里必须各用一个(p 和 c),否则互相踩。
② 消费者在 region 块内部声明 int aux,却在块外调用 consume(aux)——C 语言里这是作用域越界,应把 aux 声明在 while 之前。
③ 消费者函数缺少左花括号(Consumidor(void *arg) 后面直接 while)。
这些是伪代码的松散写法,考试照写概念即可,但你要看得出问题。
五、Variables condición:会睡觉的条件等待
p.22–p.28Variables condición · 定义、挂起、配 mutex、通知
▸ 原页截图 p.22

Variables condición
条件变量。
Las variables de condición son un mecanismo de sincronización que permite a las hebras esperar hasta que se cumpla una determinada condición sobre el estado compartido
条件变量是一种同步机制,让线程一直等到共享状态上某个条件成立为止。
Una hebra puede suspenderse mientras la condición no se cumpla, en lugar de comprobarla continuamente
条件未满足时线程可以挂起,而不是不停地检查。
Así se evita el consumo de CPU asociado a la espera activa
这样就避免了忙等带来的 CPU 消耗。
Se utilizan conjuntamente con un mutex, que protege el estado compartido y permite comprobar la condición de forma segura
它们总是与 mutex 配合使用:mutex 保护共享状态,并让条件能够被安全地检查。
Cuando una hebra modifica el estado compartido, puede notificar a las hebras que están esperando mediante una señal o un aviso general
当某个线程修改了共享状态时,它可以通知正在等待的线程——用信号(señal)或广播(aviso general)。
| 西语术语 | 中文 | 说明 |
|---|---|---|
| suspenderse | 挂起 | 让出 CPU,进入睡眠 |
| espera activa | 忙等 | 要避免的东西 |
| señal | 信号 | 唤醒 一个(signal) |
| aviso general | 广播 | 唤醒 全部(broadcast) |
① 用于等待共享状态上的条件成立;
② 挂起而不是持续检查;
③ 必须与 mutex 配合(保护共享状态);
④ 状态改变后要通知:señal(一个)或 aviso general(全部)。
「señal vs aviso general」正是 pthread_cond_signal 与 pthread_cond_broadcast 的西语叫法。
Variables condición · 初始化与销毁
▸ 原页截图 p.23

int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
Variables condición - Inicialización
条件变量 —— 初始化。
Alternativamente (con atributos por defecto):
另一种写法(使用默认属性):
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Destrucción cuando no se va a usar más y ninguna hebra la está usando:
当它不再被使用、且没有任何线程正在使用它时,进行销毁:
int pthread_cond_destroy(pthread_cond_t *cond);
pthread_mutex_init ↔ pthread_cond_init
pthread_mutex_destroy ↔ pthread_cond_destroy
PTHREAD_MUTEX_INITIALIZER ↔ PTHREAD_COND_INITIALIZER
考试喜欢用这种「对称性」出填空题。
Variables condición · wait / signal / broadcast / timedwait
▸ 原页截图 p.24

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
| 函数 | 作用 | 关键点 |
|---|---|---|
| cond_wait | 原子地:释放 mutex + 睡在 cond 上 | 醒来时重新持有 mutex |
| cond_signal | 唤醒至少一个等待者 | 没有等待者则什么也不发生 |
| cond_broadcast | 唤醒全部等待者 | 对应西语 aviso general |
| cond_timedwait | 带超时的 wait | 超时返回 ETIMEDOUT |
Variables condición · POSIX 六步运作流程
▸ 原页截图 p.25

Funcionamiento de las variables condición en POSIX
条件变量在 POSIX 中的运作流程:
1. Una hebra obtiene un mutex (Las variables condición siempre tienen asociado un mutex)
1. 线程取得 mutex(条件变量总是关联着一个 mutex)。
2. Comprueba la condición bajo la protección del mutex
2. 在 mutex 的保护下检查条件。
3. Si la condición es cierta la hebra continúa su tarea y libera el mutex cuando sea apropiado
3. 如果条件为真,线程继续自己的工作,并在合适的时候释放 mutex。
4. Si la condición no es cierta, el mutex se libera y la hebra se duerme sobre la variable condición
4. 如果条件不成立:释放 mutex,并睡在该条件变量上。
5. Cuando se produzca un cambio en la condición se deberá producir una llamada que despierte a la hebra dormida
5. 当条件发生变化时,必须发起一次调用,唤醒睡着的线程。
6. La hebra despertada vuelve a tomar el mutex, vuelve a comprobar la condición….y se vuelve a 3
6. 被唤醒的线程重新取得 mutex、重新检查条件……然后回到第 3 步。
| 步 | 动作 | 持有 mutex? |
|---|---|---|
| 1 | lock | 否 → 是 |
| 2 | 检查条件 | 是(必须) |
| 3 | 条件真 → 干活 → unlock | 是 → 否 |
| 4 | 条件假 → 放锁 + 睡 | 是 → 否 |
| 5 | 别人改状态后 signal | 是 / 否皆可 |
| 6 | 醒来 → 重新 lock → 回到 2 | 否 → 是 |
Variables condición · SIEMPRE reevaluar + spurious wakeups
▸ 原页截图 p.26

SIEMPRE tiene que reevaluarse la condición
必须始终重新求值条件(每次醒来都要再看一遍)。
No tenemos garantía de que cuando volvamos a ejecutar, la condición siga siendo cierta y, además, se pueden producir spurious wakeups
我们无法保证重新执行时条件仍然成立;而且还会出现虚假唤醒(spurious wakeups)。
Uso variables condición
条件变量的用法:
void hebra1() { … pthread_mutex_lock(&m); while (!micondicion) { pthread_cond_wait(&c, &m); } …duerme… Hacealgo(); pthread_mutex_unlock(&m); } void hebra2() { … pthread_mutex_lock(&m); micondicion = 1; pthread_cond_signal(&c); pthread_mutex_unlock(&m); } // pseudocódigo
…duerme…
……(此处睡眠)……
Hacealgo();
做某事(条件成立后才执行的工作)。
| 写法 | 正确性 | 原因 |
|---|---|---|
| if (!cond) wait(...) | 错误 | 被虚假唤醒后直接进入临界区 |
| while (!cond) wait(...) | 正确 | 醒来后重新检查,仍为假则继续睡 |
① 为什么用 while 不用 if:因为醒来后条件可能不成立(别人抢先、或虚假唤醒)。
② 什么是 spurious wakeup:没有被 signal 也自己醒了——POSIX 允许实现这样做,程序必须能容忍。
背下这句西语原句:SIEMPRE tiene que reevaluarse la condición。
PC con variables condición · 全局变量与 main
▸ 原页截图 p.27

#include <pthread.h> #include <stdio.h> #define N 10 pthread_mutex_t mutex; pthread_cond_t puedo_producir; pthread_cond_t puedo_consumir; int buffer[N]; int nelem = 0; int i = 0; int j = 0; int main() { pthread_t productor, consumidor; pthread_mutex_init(&mutex, NULL); pthread_cond_init(&puedo_producir, NULL); pthread_cond_init(&puedo_consumir, NULL); pthread_create(&productor, NULL, Productor, NULL); pthread_create(&consumidor, NULL, Consumidor, NULL); pthread_join(productor, NULL); pthread_join(consumidor, NULL); pthread_mutex_destroy(&mutex); pthread_cond_destroy(&puedo_producir); pthread_cond_destroy(&puedo_consumir); return 0; }
Productor-consumidor con variables condicionales
用条件变量实现的生产者—消费者。
| 全局变量 | 类型 | 含义 |
|---|---|---|
| mutex | pthread_mutex_t | 保护全部共享状态 |
| puedo_producir | pthread_cond_t | 「可以生产」的等待队列 |
| puedo_consumir | pthread_cond_t | 「可以消费」的等待队列 |
| buffer[N] | int[10] | 环形缓冲区 |
| nelem | int | 当前元素数 |
| j | int | 生产者的写指针 |
| i | int | 消费者的读指针 |
PC con variables condición · Productor / Consumidor
▸ 原页截图 p.28

void *Productor(void *arg) { int dato = 0; while (1) { dato++; pthread_mutex_lock(&mutex); while (nelem == N) pthread_cond_wait(&puedo_producir, &mutex); buffer[j] = dato; j = (j + 1) % N; nelem++; pthread_cond_signal(&puedo_consumir); pthread_mutex_unlock(&mutex); } } void *Consumidor(void *arg) { while (1) { int aux; pthread_mutex_lock(&mutex); while (nelem == 0) pthread_cond_wait(&puedo_consumir, &mutex); aux = buffer[i]; i = (i + 1) % N; nelem--; pthread_cond_signal(&puedo_producir); pthread_mutex_unlock(&mutex); printf("%d\n", aux); } }
lock → while(条件不满足) wait → 改状态 → signal(对方) → unlock。
注意 signal 放的位置:在 unlock 之前、在改完状态之后。改状态在前保证被唤醒者看到的是新值;signal 在解锁前是常见的安全写法。
① 必须是 while (nelem == N),不能写 if(虚假唤醒);
② wait 的第二个参数必须是同一把 mutex;
③ 两个不同的条件变量不能混用。
违反任一条,程序在半数情况下「看起来能跑」,但在压力测试下必挂——这正是考卷爱出的「看似正确」的代码。
六、Monitores:把同步封装进类型里
p.29–p.31Monitores · 对 RCC 的三条批评
▸ 原页截图 p.29

Monitores
监视器(管程)。
Críticas a las RCC
对条件临界区(RCC)的批评:
El procedimiento de bloqueo de las hebras no es muy eficiente
线程的阻塞流程效率不高。
Cuando una hebra evalúa a false la expresión booleana de una RCC se vuelve a bloquear en la cola de entrada. Cuando la desbloquean, no hay seguridad de que la expresión booleana sea ahora cierta
当线程发现 RCC 的布尔表达式为假时,它会重新阻塞在入口队列;而当它被唤醒时,并不能保证布尔表达式此刻已经为真。
Este comportamiento puede llegar a ser similar al de una espera activa
这种行为可能退化成类似忙等的效果。
Una solución es que la hebra que sale de la RCC evalúe las expresiones booleanas de las hebras que esperan, y despierte a la primera que pueda continuar
一种解决思路是:让离开 RCC 的线程去评估等待中线程的布尔表达式,并唤醒第一个能继续的。
El problema de esta solución es que, muchas veces, en las expresiones booleanas aparecen variables locales, a las que no tienen acceso el resto de las hebras
但这个方案的问题是:布尔表达式里常常出现局部变量,而其他线程访问不到这些局部变量。
El código de acceso al recurso protegido está distribuido por el código de las hebras
受保护资源的访问代码分散在各个线程的代码里。
Desde el punto de vista de la seguridad, esto no es adecuado, ya que cualquiera puede modificar el procedimiento de acceso a un recurso, violando alguna propiedad básica
从安全性角度看这不合适——因为任何人都能改动某个资源的访问流程,从而违反基本性质。
| # | 批评点 | 后果 |
|---|---|---|
| 1 | 阻塞流程效率低,唤醒后条件未必为真 | 近似忙等 |
| 2 | 由出区者评估他人条件 → 局部变量不可见 | 方案不可行 |
| 3 | 访问代码分散在各线程中 | 安全性差,谁都能改 |
Monitores · Hoare & Hansen 的定义
▸ 原页截图 p.30

El concepto de monitor definida por Hoare y Hansen a mediados de los 70
monitor 这个概念由 Hoare 和 Hansen 在 70 年代中期提出。
Un monitor es una estructura proporcionada por un lenguaje de programación concurrente que permite encapsular todos aspectos de sincronización asociados a un recurso
monitor 是并发编程语言提供的一种结构,它能把某个资源相关的所有同步方面封装起来。
habitualmente también anidado en el monitor
(被保护的资源)通常也嵌套在 monitor 内部。
Por definición, todos los procedimientos o funciones exportados (públicos) por el monitor son ejecutados siempre en exclusión mutua
按定义,monitor 导出的所有过程/函数(public)都始终在互斥下执行。
Además, proporciona variables de tipo condición para modelar fácilmente las condiciones de sincronización
此外,它提供条件变量,用来方便地建模同步条件。
En los lenguajes de programación actuales no hay una construcción específica para usar monitores
在当今的编程语言中并没有专门用来实现 monitor 的构造。
Es más bien una “filosofía” sobre cómo construir el código
它更像是一种「哲学」——关于如何组织代码。
| 要素 | 内容 |
|---|---|
| 提出者 | Hoare y Hansen |
| 时间 | mediados de los 70 |
| 封装 | 资源 + 所有同步方面 |
| 导出过程 | 天生互斥(无需手写 lock/unlock) |
| 条件等待 | 靠 variables condición |
| 现代现状 | 无专用语法,只是一种 filosofía |
Monitores · 作为「概念」的价值
▸ 原页截图 p.31

Monitores
监视器。
Los monitores como “concepto” son una técnica de sincronización muy interesante
作为「概念」,monitor 是一种非常有意思的同步技术。
Se fuerza al programador a manipular los datos compartidos a través del código del monitor
它强制程序员通过 monitor 的代码来操作共享数据。
De esa forma no se olvidan desbloquear las zonas de exclusión mutua
这样一来就不会忘记解锁互斥区。
七、Productor-consumidor con buffer acotado
p.32–p.35Buffer acotado · 问题描述与三条性质
▸ 原页截图 p.32

Productor consumidor con Buffer Acotado
有界缓冲区的生产者—消费者。
Una hebra de tipo productor produce de forma ininterrumpida datos que deben ser consumidos por otra hebra de tipo consumidor
生产者线程不间断地生产数据,这些数据必须由消费者线程消费。
Las hebras utilizan un buffer intermedio donde se almacenan temporalmente los datos producidos, que todavía no se han consumido
线程使用一个中间缓冲区,临时存放已生产但尚未消费的数据。
El sistema debe satisfacer las siguientes propiedades
系统必须满足以下性质:
El buffer se utiliza en exclusión mutua
① 缓冲区以互斥方式使用。
El productor no puede escribir sobre el buffer, si está lleno
② 缓冲区满时,生产者不能写入。
El consumidor no puede extraer un dato, si el buffer está vacío
③ 缓冲区空时,消费者不能取出数据。
| 性质 | 类型 | 解决手段 |
|---|---|---|
| ① 互斥使用 | exclusión mutua | pthread_mutex_t |
| ② 满不能写 | condición de sincronización | cond buffer_no_lleno |
| ③ 空不能取 | condición de sincronización | cond buffer_no_vacio |
Buffer acotado · struct buffer + producir()
▸ 原页截图 p.33

#define BUFF_SIZE 10 typedef struct { pthread_mutex_t mutex; pthread_cond_t buffer_no_lleno; pthread_cond_t buffer_no_vacio; int count, first, last; int buf[BUFF_SIZE]; } buffer; int producir(int item, buffer *B) { pthread_mutex_lock(&B->mutex); while (B->count == BUFF_SIZE) { pthread_cond_wait(&B->buffer_no_lleno, &B->mutex); } /* Insertar dato en buffer y actualizar count y last */ pthread_cond_signal(&B->buffer_no_vacio); pthread_mutex_unlock(&B->mutex); return 0; }
Productor Consumidor Buffer Acotado
生产者 消费者 有界缓冲区。
/* Insertar dato en buffer y actualizar count y last */
/* 把数据插入缓冲区,并更新 count 和 last */
| 字段 | 作用 |
|---|---|
| mutex | 保护整个结构体 |
| buffer_no_lleno | 生产者在这里等「不满」 |
| buffer_no_vacio | 消费者在这里等「不空」 |
| count | 当前元素个数(= 上一节的 nelem) |
| first | 下一次读的位置 |
| last | 下一次写的位置 |
| buf[10] | 存放数据的数组 |
另外注意 first/last 与 p.28 的 i/j 是同一对东西,只是改名了。
Buffer acotado · consumir() 与 inicializar()
▸ 原页截图 p.34

int consumir(int *item, buffer *B) { pthread_mutex_lock(&B->mutex); while (B->count == 0) { pthread_cond_wait(&B->buffer_no_vacio, &B->mutex); } /* Tomar dato del buffer y actualizar count y first */ pthread_cond_signal(&B->buffer_no_lleno); pthread_mutex_unlock(&B->mutex); return 0; } int inicializar(buffer *B) { /* Inicializar atributos */ /* mutexes y variables condición */ }
/* Tomar dato del buffer y actualizar count y first */
/* 从缓冲区取走数据,并更新 count 和 first */
/* Inicializar atributos */
/* 初始化各属性 */
/* mutexes y variables condición */
/* mutex 与条件变量 */
| 对比 | producir | consumir |
|---|---|---|
| 等待条件 | count == BUFF_SIZE | count == 0 |
| 等待的 cond | buffer_no_lleno | buffer_no_vacio |
| signal 对象 | buffer_no_vacio | buffer_no_lleno |
| 更新的指针 | last | first |
只有一个等待集的问题 · 为什么要多个 cond
▸ 原页截图 p.35

El problema de tener sólo un conjunto de espera
只有一个等待集的问题。
Cuando se despierta una hebra, no puede suponer que la condición por la que se suspendió se satisfice
当一个线程被唤醒时,它不能假设自己当初因之挂起的那个条件已经满足。
Por ejemplo, si se usa broadcast, todas las hebras se despiertan con independencia de las condiciones por las que esperan
例如,若使用 broadcast,所有线程都会被唤醒,不管它们各自在等什么条件。
Para algunos algoritmos esto no es un problema, ya que, las condiciones no pueden ser ciertas simultáneamente
对某些算法来说这不是问题——因为那些条件不可能同时成立。
Por ejemplo, en el problema de productor-consumidor, si una hebra está esperando una condición, la otra hebra no puede estar suspendida (el buffer no puede estar lleno y vacío a la vez)
例如在生产者—消费者问题里:如果一方在等某个条件,另一方就不可能正处于挂起状态(缓冲区不可能同时既满又空)。
Pero para otros escenarios, la situación puede ser diferente
但在其他场景下,情况可能不同。
Podemos usar las variables condición para tener más “sitios” (conjuntos de espera) donde las hebras esperan por diferentes condiciones
我们可以用条件变量设置更多「站点」(等待集),让线程按各自不同的条件分别等待。
| 方案 | 唤醒精度 | 代价 |
|---|---|---|
| 一个 cond + broadcast | 低:叫醒所有,多数白醒 | CPU 抖动、惊群 |
| 一个 cond + signal | 可能叫错人 | 真需要的人还在睡 |
| 多个 cond(分站点) | 高:叫对的人 | 代码稍复杂 |
① 一个等待集里混着等不同条件的线程,signal 可能叫醒「条件还不成立」的那个;
② 用 broadcast 虽然能保证「该醒的必醒」,但会叫醒所有,产生大量无效唤醒;
③ 所以按条件划分多个等待集,才能「叫对的人」。
而 PC 问题之所以能用两个 cond 各自 signal,正是因为「满」和「空」不可能同时成立。
八、Lectores / escritores:多读者可并发,写者独占
p.36–p.40Lectores / escritores · 两条同步条件与三种组合
▸ 原页截图 p.36

El problema de los lectores/escritores
读者 / 写者问题。
Dos tipos de hebras (tipos lector y escritor) comparten un recurso (típicamente una Base de Datos)
两类线程(
El sistema debe satisfacer las siguientes condiciones de sincronización
系统必须满足下面这几条同步条件:
– Varios lectores pueden acceder a la BD simultáneamente
– 多个读者可以同时访问数据库。
– Cada escritor debe acceder a la BD en exclusión mutua con cualquier otra hebra lector o escritor
– 每个写者必须以互斥方式访问数据库,与任何其他读者线程或写者线程都
| 组合 | 能并发吗 | 依据(原文) |
|---|---|---|
| 读者 × 读者 | ✔ 能 | 条件① varios lectores … simultáneamente |
| 读者 × 写者 | ✘ 不能 | 条件② 写者与任何其他线程互斥 |
| 写者 × 写者 | ✘ 不能 | 条件② 写者本身也算 cualquier otra hebra |
main 骨架 · 四个计数器 + 两把 cond
▸ 原页截图 p.37

int main() { int i, nlec = 0, nesc = 0, wlec = 0, wesc = 0; pthread_mutex_t mutex; pthread_cond_t cond_lec, cond_esc; pthread_t lec[MAXLEC], esc[MAXESC]; //MAXLEC y MAXESC ctes pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond_lec, NULL); pthread_cond_init(&cond_esc, NULL); for (i=0; i<MAXESC; i++) pthread_create(&(esc[i]), NULL, escritores, NULL); for (i=0; i<MAXLEC; i++) pthread_create(&(lec[i]), NULL, lectores, NULL); pthread_join(esc[0], NULL); }
//MAXLEC y MAXESC ctes
//MAXLEC 与 MAXESC 是常量。
| 状态变量 | 含义 | 谁会读它 |
|---|---|---|
| nlec | 此刻正在里面读的读者数 | pre_leer / pre_escribir / post_leer |
| nesc | 此刻正在里面写的写者数(0 或 1) | pre_leer / pre_escribir |
| wlec | 在门外排队的读者数 | post_escribir |
| wesc | 在门外排队的写者数 | post_escribir(改写者优先时才用) |
| mutex | 保护上面四个计数器的唯一一把锁 | 全部四个函数 |
| cond_lec | 读者的候诊室(等待集) | pre_leer / post_escribir |
| cond_esc | 写者的候诊室 | pre_escribir / post_leer / post_escribir |
三段式 · pre / 操作 / post(这正是 monitor 的主张)
▸ 原页截图 p.38

void *escritores(void *arg) { while (1) { pre_escribir(); escribir(); post_escribir(); } } void *lectores(void *arg) { while(1) { pre_leer(); leer(); post_leer(); } }
Observar, como se encapsulan las condiciones de sincronización en funciones, tal y como proponen los monitores
请注意看:同步条件是如何被封装进函数里的——恰恰就是 monitor(管程)所主张的做法。
| 线程体 | 进门(pre) | 干活 | 出门(post) |
|---|---|---|---|
| escritores | pre_escribir() | escribir() | post_escribir() |
| lectores | pre_leer() | leer() | post_leer() |
| 谁负责加解锁 | pre 负责 lock + 可能 wait;post 负责更新计数 + signal + unlock——线程体本身一行锁都不用写 | ||
① 分离关注点——业务代码 leer() / escribir() 里看不到任何 mutex,干净;
② 复用与不漏——所有线程走同一条路径,不会有人忘了 unlock;
③ 向 monitor 过渡——原文这句「tal y como proponen los monitores」就是在暗示:pre/post 再封装一层,就是管程。
pre_leer / post_leer · 读者的登记与「接力棒」
▸ 原页截图 p.39

void pre_leer() { pthread_mutex_lock(&mutex); while (nesc > 0) { wlec++; pthread_cond_wait(&cond_lec, &mutex); wlec—-; } nlec++; pthread_cond_signal(&cond_lec); // Por si hay más lectores esperando pthread_mutex_unlock(&mutex); } void post_leer() { pthread_mutex_lock(&mutex); nlec—-; if (nlec == 0) pthread_cond_signal(&cond_esc); pthread_mutex_unlock(&mutex); }
// Por si hay más lectores esperando
// 以防还有其他读者在等。
| 行 | 做什么 | 为什么必须这样 |
|---|---|---|
| while (nesc > 0) | 有写者在写 → 读者必须等 | 条件②:写者与读者互斥;用 while 不用 if(醒来要复检) |
| wlec++ | 登记「门外又多了一个读者」 | 让 post_escribir 知道该不该叫读者 |
| cond_wait | 放开 mutex 然后睡进 cond_lec | 不放锁的话,写者永远解不了锁 → 死锁 |
| wlec-- | 被叫醒后从门外名单里划掉 | 「我进去了,别把我算成排队的」 |
| nlec++ | 正式进入,读者计数 +1 | 后来的写者据此判断「里面有人读」 |
| signal(cond_lec) | 接力:把这个候诊室的下一个读者也叫醒 | 见下方 exam —— 这是全页最关键的一行 |
| unlock | 放开 mutex,让读者们真正并行读 | 读者之间不互斥,所以可以同时在里面 |
同理看 post_leer:只有 nlec == 0(最后一个读者离开)时才 signal(&cond_esc)——因为写者之间互斥,叫一个就够。
另外:若把 while 写成 if,遇到虚假唤醒(p.26)就会在写者仍在写的时候闯进去——必扣分。
pre_escribir / post_escribir · 为什么这套算法是「读者优先」
▸ 原页截图 p.40

void pre_escribir() { pthread_mutex_lock(&mutex); while ((nesc > 0) || (nlec > 0)) { wesc++; pthread_cond_wait(&cond_esc, &mutex); wesc—-; } nesc++; pthread_mutex_unlock(&mutex); } void post_escribir() { pthread_mutex_lock(&mutex); nesc—-; if (wlec > 0) pthread_cond_signal(&cond_lec); else pthread_cond_signal(&cond_esc); pthread_mutex_unlock(&mutex); }
Prioridad a los lectores
读者优先(本页页脚的结论标签)。
¿Como se daría prioridad a los escritores ?
那要怎么给写者优先呢?
¿Podríamos usar broadcast para despertar a los lectores?
我们能不能用 broadcast 来唤醒读者?
| 位置 | 原算法(读者优先) | 改成写者优先 |
|---|---|---|
| pre_leer | while (nesc > 0) | while ((nesc > 0) || (wesc > 0)) |
| post_escribir | if (wlec > 0) signal(cond_lec) else signal(cond_esc) | if (wesc > 0) signal(cond_esc) else broadcast(cond_lec) |
① 为什么原文是读者优先?两处证据:pre_leer 只检查 nesc > 0、不看 wesc,所以新读者可以插到等待写者前面;post_escribir 又先叫读者(if (wlec > 0))。读者源源不断时 → 写者饿死(inanición / starvation)。
② 怎么给写者优先?把上表两处一改:读者进门时也检查 wesc > 0(有写者在等就不放新读者),写者出门时先叫写者。
③ 能用 broadcast 唤醒读者吗?能。因为读者之间本来就可并发,一次全叫醒没有正确性问题,还省掉 signal 的接力;代价是「惊群」——若有写者恰好又抢进来,醒来的读者得再睡回去。用了 broadcast,wlec 这个计数器就基本没用了。
九、El barbero dormilón:四条同步条件与一个锁
p.41–p.51El barbero dormilón · 场景设定(两扇门、一把椅子、一排等候椅)
▸ 原页截图 p.41

El problema del barbero dormilón
睡眠理发师问题(
Supongamos que tenemos una barbería con dos puertas, una silla para el barbero, y unas sillas para los clientes que esperan.
假设我们有一间理发店:两扇门、一把理发椅,还有若干给等候客人坐的椅子。
Los clientes entran por una puerta y salen por la otra.
客人从一扇门进、从另一扇门出。
El barbero se pasa la vida pelando clientes, pero cuando no hay nadie en la barbería se echa un sueño en la silla del barbero.
理发师一辈子都在给客人剪头发;可店里一个人都没有的时候,他就在理发椅上睡一觉。
Cuando llega un cliente, si el barbero está durmiendo, lo despierta, se sienta en la silla del barbero y espera mientras que el barbero lo pela.
来了一位客人时:若理发师正在睡觉,客人就把他叫醒,自己坐上理发椅,然后等着理发师给他剪。
Si llega un cliente y el barbero está ocupado, el cliente se duerme en una de las otras sillas.
若来客人时理发师正忙着,客人就到别的椅子上睡一觉(等候)。
Cuando el barbero termina de pelar a un cliente, le abre la puerta de salida, que es cerrada por el cliente que sale.
理发师剪完一位客人后,给他打开出口的门;这扇门由离店的客人自己关上。
Si hay más clientes esperando, el barbero despierta a uno de ellos, sino se va a dormir.
若还有别的客人在等,理发师就叫醒其中一位;不然他就去睡。
执行序列 · 为什么恰好是四条同步条件
▸ 原页截图 p.42

Ejecución del sistema:
系统的执行序列如下:
barbero disponible → nuevo cliente se sienta en la silla → barbero pela cliente → barbero abre la puerta de salida → cliente se va cierra la puerta → barbero disponible
理发师空闲 → 新客人坐到椅子上 → 理发师给客人剪 → 理发师打开出口门 → 客人离开并关门 → 理发师重新空闲。
Por lo tanto, tenemos cuatro condiciones de sincronización:
因此,我们一共有四条同步条件:
| # | 步骤(西语) | 中文 | 谁在等谁 |
|---|---|---|---|
| 1 | barbero disponible | 理发师空闲 | 起点:blibre = 1 |
| 2 | nuevo cliente se sienta en la silla | 新客人坐上理发椅 | 客人等理发师 → C1 |
| 3 | barbero pela cliente | 理发师开始剪 | 理发师等客人坐好 → C2 |
| 4 | barbero abre la puerta de salida | 理发师打开出口门 | 客人等门开 → C3 |
| 5 | cliente se va, cierra la puerta | 客人离开并关门 | 理发师等门关 → C4 |
| 6 | barbero disponible | 理发师回到空闲 | 循环回到 1 |
C1 · 理发师不空闲,新客人不许坐下
▸ 原页截图 p.43

Ejecución del sistema:
系统的执行序列:
barbero disponible → nuevo cliente se sienta en la silla → barbero pela cliente → barbero abre la puerta de salida → cliente se va cierra la puerta → barbero disponible
理发师空闲 → 新客人坐上椅子 → 理发师剪 → 理发师打开出口门 → 客人离开并关门 → 理发师重新空闲。(与 p.42 逐字相同,后三页也重复这段引入)
Por lo tanto, tenemos cuatro condiciones de sincronización:
因此我们共有四条同步条件:
– C1: Un nuevo cliente no se sienta en la silla del barbero hasta que el barbero no está disponible (boolean blibre; condition cblibre )
– C1:新客人不会坐到理发椅上,直到理发师「不空闲」为止 ——(声明 boolean blibre; condition cblibre)。
| C1 的两个变量 | 名字含义 | 谁写它 | 谁读它 |
|---|---|---|---|
| blibre | barbero libre = 理发师空闲 | 理发师(下班时置 1);客人坐上后置 0 | 客人 |
| cblibre | condition blibre = 「等理发师空闲」的候诊室 | signal | 客人 cond_wait |
另外这句是西语典型的冗余否定:no … hasta que no … 两个 no 意思仍是肯定(「直到…才…」),不是双重否定。写作模块里照这个语感写才地道,但别漏了虚拟式。
C2 · 客人没坐好,理发师不许动剪刀
▸ 原页截图 p.44

– C2: El barbero no pela al cliente hasta que no se ha sentado en su silla (boolean socupada; condition csocupada)
– C2:客人没有坐到他的椅子上之前,理发师不给他剪 ——(boolean socupada; condition csocupada)。
| C2 的两个变量 | 名字含义 | 谁写它 | 谁读它 |
|---|---|---|---|
| socupada | silla ocupada = 理发椅已被占 | 客人坐上后置 1;理发师接手后置 0 | 理发师 |
| csocupada | 「等椅子被占」的候诊室 | signal | 理发师 cond_wait |
· C1 = 客人等理发师(blibre)
· C2 = 理发师等客人(socupada)
考试最爱考的就是问「C1 和 C2 分别是谁等谁」。判读口诀:看句子主语谁「不动」——不动的那一方就是等待方(C1 里 un nuevo cliente no se sienta → 客人等;C2 里 el barbero no pela → 理发师等)。
C3 · 理发师不开门,客人不许走
▸ 原页截图 p.45

– C3: El cliente no se va hasta que el barbero no le ha abierto la puerta (boolean pabierta; condition cpabierta)
– C3:理发师没有给他打开门之前,客人不走 ——(boolean pabierta; condition cpabierta)。
| C3 的两个变量 | 名字含义 | 谁写它 | 谁读它 |
|---|---|---|---|
| pabierta | puerta abierta = 出口门已打开 | 理发师剪完置 1;客人离开后置 0 | 客人 |
| cpabierta | 「等门打开」的候诊室 | signal | 客人 cond_wait |
客人等 → C1(等空闲)、C3(等开门);理发师等 → C2(等坐好)、C4(等关门)。
这个 2 vs 2 的对称结构背下来,后面 cortar() 与 finpelar() 的代码就自然分得清:cortar 里等 C1 和 C3,finpelar 里等 C4,siguiente 里等 C2。
C4 · 客人没关门,理发师不算空闲(含原文笔误)
▸ 原页截图 p.46

– C4: El barbero no está disponible hasta que el cliente ha cerrado la puerta (boolean pabierta; condition cciclo)
– C4:客人把门关上之前,理发师都「不算空闲」 ——(boolean pabierta; condition cciclo)。
| # | 条件(西语) | 中文 | 布尔 | cond | 谁等 |
|---|---|---|---|---|---|
| C1 | cliente no se sienta hasta que barbero libre | 理发师不空闲,客人不坐 | blibre | cblibre | 客人 |
| C2 | barbero no pela hasta que cliente sentado | 客人没坐好,理发师不剪 | socupada | csocupada | 理发师 |
| C3 | cliente no se va hasta que puerta abierta | 门没开,客人不走 | pabierta | cpabierta | 客人 |
| C4 | barbero no disponible hasta que puerta cerrada | 门没关,理发师不算空闲 | pabierta(与 C3 共用,见 warn) | cciclo | 理发师 |
① C3 与 C4 都写 boolean pabierta——看上去像重名 bug,但 p.49–p.50 的真实代码确实只用一个 pabierta:客人离开时 pabierta=0; pthread_cond_signal(&cciclo);,理发师则 while (pabierta) pthread_cond_wait(&cciclo,&m);。能共用的原因正是 p.35 那条规则:C3(客人等门「开」)与 C4(理发师等门「关」)不可能同时成立,所以一面旗子够用。代价是可读性差,答题时最好注明「此处两条条件互斥,故共用一个标志位」。
② C2 在本页写成 var socupada:boolean; csocupada:condition,与前三条「boolean x; condition cx」格式不一致——var 是伪代码关键字,POSIX 里没有它,属于排版没统一。
真实代码 · 全局变量、四个 cond 与 main
▸ 原页截图 p.47

#include <stdio.h> #include <pthread.h> #include <unistd.h> #define MAXI 50 pthread_mutex_t m; int blibre = 0; int pabierta = 0; int socupada = 0; pthread_cond_t cblibre = PTHREAD_COND_INITIALIZER, cpabierta = PTHREAD_COND_INITIALIZER, cciclo = PTHREAD_COND_INITIALIZER, csocupada = PTHREAD_COND_INITIALIZER; int main () { pthread_t th[MAXI], thbar; pthread_attr_t attr; int id[MAXI]; int i; pthread_attr_init(&attr); pthread_mutex_init(&m, NULL); pthread_create(&thbar, &attr, Barbero, NULL); for (i=0; i<MAXI; i++) { id[i] = i; pthread_create(&th[i], &attr, cliente, &id[i]); } pthread_join(th[0], NULL); return 0; }
| 声明 | 用途 | 对应 |
|---|---|---|
| #define MAXI 50 | 客人线程总数 | 50 个 th[i] |
| pthread_mutex_t m | 唯一一把锁,保护全部状态 | 四个函数都 lock(&m) |
| blibre = 0 | 理发师不空闲(初始没人,他在睡) | C1 → cblibre |
| pabierta = 0 | 出口门关着 | C3 + C4 → cpabierta / cciclo |
| socupada = 0 | 理发椅空着 | C2 → csocupada |
| thbar | 1 个理发师线程 | Barbero() |
| th[MAXI] | 50 个客人线程 | cliente() |
| id[MAXI] | 给每个客人一个编号 | &id[i] 传给线程 |
Barbero() 与 cliente() · 线程体只调用「monitor 函数」
▸ 原页截图 p.48

void *Barbero (void *arg) { while (1) { // función del monitor siguiente(); sleep(1); printf("Pelando\n"); // función del monitor finpelar(); } } void *cliente (void *arg) { int id; id = *((int *) arg); while (1) { // función del monitor cortar(id); sleep(2); } }
// función del monitor
// monitor 的函数(管程的过程)。
printf("Pelando\n");
printf("Pelando\n"); → 打印「正在剪」。
| 线程 | 循环体 | 谁在等 |
|---|---|---|
| Barbero | siguiente() → sleep(1) → printf → finpelar() | siguiente 里等 C2;finpelar 里等 C4 |
| cliente | cortar(id) → sleep(2) | cortar 里等 C1、C3 |
考「为什么说这段代码体现了 monitor」→ 就答:同步与操作被合并封装进函数,调用者不接触任何同步原语。
另外 id = *((int *) arg); 是标准的「从 void * 取回 int」写法:先转 int * 再解引用,括号少一个都是语法错。
cortar(id) · 客人端:两次等待、两次放行
▸ 原页截图 p.49

void cortar (int id) { pthread_mutex_lock(&m); printf("%d Quiero cortarme\n", id); while (!blibre) pthread_cond_wait(&cblibre, &m); blibre = 0; socupada = 1; pthread_cond_signal(&csocupada); while (!pabierta) pthread_cond_wait(&cpabierta, &m); pabierta = 0; pthread_cond_signal(&cciclo); printf("%d Saliendo\n", id); pthread_mutex_unlock(&m); }
printf("%d Quiero cortarme\n", id);
printf("%d Quiero cortarme\n", id); → 打印「%d 号,我想剪头发」。
printf("%d Saliendo\n", id);
printf("%d Saliendo\n", id); → 打印「%d 号,正在离开」。
| 行 | 动作 | 对应条件 |
|---|---|---|
| lock(&m) | 进门先拿锁 | — |
| while (!blibre) wait(cblibre) | 理发师不空闲就睡在 cblibre | C1(客人等) |
| blibre = 0 | 占了理发师 → 他不再空闲 | C1 的另一半 |
| socupada = 1 | 坐上椅子 → 椅子被占 | C2 的前半 |
| signal(&csocupada) | 叫醒理发师:可以剪了 | C2 的通知 |
| while (!pabierta) wait(cpabierta) | 门没开就睡在 cpabierta | C3(客人等) |
| pabierta = 0 | 把门关回去 → 门不再「开着」 | C4 的前半 |
| signal(&cciclo) | 叫醒理发师:我关好门了 | C4 的通知 |
| unlock(&m) | 出门放锁 | — |
① wait 用 while (!条件);② 醒来先「把自己那一侧的旗子改掉」;③ 改完立刻 signal 对方;④ 最后 unlock。
特别注意「客人关门」这个动作:pabierta = 0 是客人写、理发师读——旗子由谁改、由谁等,必须和 p.42 的交接点一一对上,写反就是死锁。
finpelar() · 理发师端:开门之后还要等门关
▸ 原页截图 p.50

void finpelar () { pthread_mutex_lock(&m); pabierta = 1; pthread_cond_signal(&cpabierta); while (pabierta) pthread_cond_wait(&cciclo, &m); pthread_mutex_unlock(&m); }
| 行 | 动作 | 含义 |
|---|---|---|
| pabierta = 1 | 把门「打开」 | 通知位:客人可以走了 |
| signal(&cpabierta) | 叫醒等在 cpabierta 上的客人 | C3 的通知 |
| while (pabierta) wait(cciclo) | 只要门还开着就睡 | C4:等客人把门关上 |
| unlock(&m) | 放锁 | 服务周期闭合 |
因为这里等的是「门关掉」——只要门还开着(pabierta == 1),理发师就得继续等;等客人执行 pabierta = 0 并 signal(&cciclo) 之后,循环条件为假,理发师才继续。
一句话:while 里写的是「继续睡的条件」,不是「醒来的条件」——这是全章最容易翻车的一处极性错误。
siguiente() · 理发师叫号:先举旗,再睡觉
▸ 原页截图 p.51

void siguiente () { pthread_mutex_lock(&m); blibre = 1; pthread_cond_signal(&cblibre); while (!socupada) pthread_cond_wait(&csocupada, &m); socupada = 0; pthread_mutex_unlock(&m); }
| 行 | 动作 | 含义 |
|---|---|---|
| blibre = 1 | 举旗:我空闲了 | C1 的前半 |
| signal(&cblibre) | 叫一位等着的客人 | C1 的通知 |
| while (!socupada) wait(csocupada) | 客人没坐上就继续睡 | C2(理发师等) |
| socupada = 0 | 接手椅子 → 椅子不再「被占」 | C2 的另一半 |
| unlock(&m) | 放锁,开始剪 | — |
· 若先 wait 后 signal:理发师会在客人还没被叫醒时睡死,没人来叫他(客人不知道他空闲)→ 死锁。
· 正确的因果是:「我先宣布我空了(置 1 + signal),然后才躺下等客人坐好」。
对照 cortar:客人是「先等空闲、再置 0、再 signal」——一个先给后等,一个先等后给,正好互补。
| 条件 | 客人端(cortar) | 理发师端(siguiente / finpelar) |
|---|---|---|
| C1 客人等空闲 | while(!blibre) wait(cblibre) | siguiente: blibre=1; signal(cblibre) |
| C2 理发师等坐好 | socupada=1; signal(csocupada) | siguiente: while(!socupada) wait(csocupada); socupada=0 |
| C3 客人等开门 | while(!pabierta) wait(cpabierta) | finpelar: pabierta=1; signal(cpabierta) |
| C4 理发师等关门 | pabierta=0; signal(cciclo) | finpelar: while(pabierta) wait(cciclo) |
十、En resumen:全章三条主线
p.52En resumen · 全章三条主线
▸ 原页截图 p.52

En resumen…
小结……
Hemos visto mecanismos de sincronización adicionales
我们(在这一部分)又见到了几种额外的同步机制。
Spinlocks solo para situaciones con esperas cortas
自旋锁只用于等待很短的情形。
Mutex con variables condicionales
互斥锁 + 条件变量。
– Más alto nivel y estructurados
– 层次更高、更结构化。
– Inconveniente en el bucle de la condición
– 缺点在于「条件的循环」(即必须手写 while 复检)。
Monitor como forma de organizar el código
管程(monitor)作为一种组织代码的方式。
| 机制 | 拿不到时 | 适用 | 主要缺点 |
|---|---|---|---|
| Spinlock | 原地空转(忙等) | 等待极短、临界区极小 | 烧 CPU;单核上纯浪费 |
| Mutex | 阻塞睡眠 | 一般的临界区 | 只能互斥,不能「等条件」 |
| Mutex + cond | 睡在某个等待集上 | 生产者消费者、读者写者 | 条件循环要自己写、容易漏 signal |
| Monitor | 由管程内部处理 | 把「数据 + 同步」封装成类型 | 语言支持(C 需手工模拟) |
① 「什么时候用 spinlock?」→ 等待极短 + 临界区极小 + 多处理器(p.8 三条件)。
② 「mutex 与条件变量的分工?」→ mutex 管「谁能进」,cond 管「什么时候能进」;锁只有一个,等待集可以有多个(p.35)。
③ 「monitor 好在哪?」→ 把同步封装进类型/过程,调用者不碰同步原语;代价是条件循环仍需掌握(原文这个 inconveniente 就是在提醒你别以为用了 monitor 就万事大吉)。
十一、专有名词总表
A–W · 全章 52 页专有名词速记表(A–W)
按西语字母排序,点页码直接跳回对应页块。最后一列是「一句话记住 / 易错点」——考前只扫这一列也能救急。
| 西语术语 | 中文 | 页 | 一句话记住 / 易错点 |
|---|---|---|---|
| A | |||
| adquirir | 获取(一把锁) | p.13 | 拿不到就阻塞;只有拿到的人才有权 unlock |
| atomicidad | 原子性:cond_wait 的「放锁 + 睡」不可分割 | p.24 | 中间不许插队,否则就有丢信号的窗口 |
| aviso general | 广播:唤醒全部等待者 | p.22 | 西语叫法 = pthread_cond_broadcast |
| B | |||
| barbero dormilón | 睡眠理发师问题 | p.41 | 两门一椅一排座;四条条件一个锁 |
| barbería | 理发店:两类线程共享的场景 | p.41 | 三处可占位置:理发椅 / 等候椅 / 门 |
| blibre | 理发师空闲标志(barbero libre) | p.43 | = 1 才允许新客人坐下;客人坐上后置 0 |
| bloqueo | 阻塞:挂起并让出 CPU | p.13 | 正面对比 spinlock 的「原地空转」 |
| broadcast | 唤醒全部等待者 | p.24 | 只有当多条条件可能同时成立时才需要它 |
| buffer acotado | 有界缓冲区 | p.32 | 三条性质:互斥 / 满不写 / 空不取 |
| BUFF_SIZE | 缓冲区容量常量 | p.33 | count == BUFF_SIZE 就是「满」 |
| C | |||
| cblibre | 「等理发师空闲」的等待集 | p.43 | 命名法:c + 布尔名,一布尔配一 cond |
| cciclo | 「等门关上」的等待集(C4) | p.46 | C3 与 C4 共用 pabierta,但 cond 分开 |
| ceder la CPU | 让出 CPU(交给别的线程) | p.13 | mutex 阻塞时会做,spinlock 绝不会做 |
| cliente | 客人线程 | p.41 | 叫醒理发师 → 坐下 → 等开门 → 关门离开 |
| cola de entrada | 入口队列 | p.20 | RCC 里抢不到 mutex 就排在这里 |
| conjunto de espera | 等待集(一个 cond 就是一个「候诊室」) | p.35 | 混着等不同条件,signal 就会叫错人 |
| condición de sincronización | 同步条件 | p.19 | mutex 管「不能同时」,它管「必须等到」 |
| consumidor | 消费者线程 | p.32 | 空不能取;取完叫生产者 |
| contador | 计数器(并发竞态的最小例子) | p.10 | 两个线程同时 ++ 就会丢更新 |
| cortar(id) | 客人端过程:坐下到离开 | p.49 | 等 C1 → 坐好通知 → 等 C3 → 关门通知 |
| cpabierta | 「等门打开」的等待集(C3) | p.45 | 睡在这里的是客人,不是理发师 |
| csocupada | 「等椅子被占」的等待集(C2) | p.44 | 睡在这里的是理发师 |
| D | |||
| deadlock | 死锁(= interbloqueo) | p.16 | trylock 不等待 ⇒ 可打破循环等待 |
| desbloqueado | 未加锁状态 | p.14 | init 之后就是它;destroy 之前必须回到它 |
| despertar | 唤醒 | p.24 | 先改共享状态,再 signal,顺序不能反 |
| destruir | 销毁(destroy) | p.14 | mutex 要解锁才能销毁;cond 要没人等才能销毁 |
| dormilón | 困倦的(barbero dormilón) | p.41 | 没人就睡,来人就被叫醒——「睡」是状态不是忙等 |
| E | |||
| EBUSY | 资源忙(错误码) | p.9 | trylock 拿不到就返回它,绝不阻塞 |
| encapsular | 封装 | p.30 | monitor 把「资源 + 所有同步方面」包进类型 |
| escribir() | 写操作(业务函数) | p.38 | 线程体里一行锁都不写,锁在 pre/post 里 |
| escritor | 写者线程 | p.36 | 与任何线程都互斥,包括别的写者 |
| espera activa | 忙等 | p.22 | 条件变量存在的唯一意义就是消灭它 |
| espera activa implícita | 隐式忙等 | p.19 | 「锁 + if 重试」的假同步——本章转折点台词 |
| exclusión mutua | 互斥:同一时刻至多一个线程在临界区 | p.4 | 临界区的定义里就写死了这一条 |
| F | |||
| filosofía | (monitor 是一种)哲学 | p.30 | 没有专用语法,重点是「如何组织代码」 |
| finpelar() | 理发师端「剪完」过程 | p.50 | 开门 signal(C3) → 自己再等门关(C4) |
| G | |||
| guarda | 守卫(布尔表达式 B) | p.19 | 为 true 才准进;为 false 就睡到 v 上 |
| H | |||
| hebra | 线程 | p.4 | 讲义全篇用 hebra,见到别慌 |
| Hoare y Hansen | 管程概念的提出者 | p.30 | 70 年代中期;导出过程始终互斥 |
| I | |||
| implícita | 隐式的 | p.19 | 隐式忙等:没人让你睡,是你自己在转 |
| inanición | 饥饿(starvation) | p.40 | 读者优先 ⇒ 写者可能永远轮不到 |
| IncVsitantes | 原文拼写(应为 IncrementarVisitantes) | p.18 | 原文笔误,照抄会编译不过 |
| inicializar | 初始化 | p.34 | count = first = last = 0 必须清零 |
| interbloqueo | 死锁(= deadlock) | p.16 | 两个西语名同义,答题写哪个都算对 |
| J | |||
| jardines (el problema de los jardines) | 花园问题(mutex 的完整实例) | p.17 | 统计游客人数;核心函数 IncVsitantes |
| L | |||
| lector | 读者线程 | p.36 | 读者之间可并发——这是本题的核心 |
| leer() | 读操作(业务函数) | p.38 | 与 escribir() 对称,同样不含锁 |
| lock | 加锁 | p.16 | NORMAL 型重复 lock ⇒ 把自己锁死 |
| M | |||
| main | 主函数:建线程、初始化锁与 cond | p.37 | 只 join(esc[0]) 是示意写法,别当标准答案 |
| MAXI | 理发店最大客数(50) | p.47 | #define MAXI 50 ⇒ 50 客人 + 1 理发师 |
| monitor | 管程 / 监视器 | p.30 | 资源 + 同步全封装;导出过程天生互斥 |
| mutex | 互斥量 | p.13 | 拿不到就睡;谁锁谁解,不能跨线程通知 |
| mutexattr | mutex 属性对象 | p.15 | 类型 / process-shared / 实时属性三组 |
| N | |||
| nesc | 正在里面写的写者数(0 或 1) | p.37 | nesc > 0 时读者必须等 |
| nlec | 正在里面读的读者数 | p.37 | 只有 nlec == 0 才通知写者 |
| NORMAL / ERRORCHECK / RECURSIVE / DEFAULT | mutex 的四种类型 | p.15 | RECURSIVE 可重复加锁,但解锁次数要一样多 |
| P | |||
| pabierta | 出口门已打开标志(puerta abierta) | p.45 | C3/C4 共用:门要么开要么关,不会同时 |
| pelar | 剪(头发) | p.41 | el barbero pela al cliente |
| POSIX | 可移植操作系统接口标准 | p.7 | 临界区的真实实现只有 Mutex 与 Spinlock |
| pre_escribir / post_escribir | 写者的进 / 出协议 | p.40 | 出门先叫读者 ⇒ 这套算法是读者优先 |
| pre_leer / post_leer | 读者的进 / 出协议 | p.39 | signal 接力棒,不需要 broadcast |
| prioceiling | 优先级上限(实时扩展属性) | p.15 | 原文即此拼写;与本章互斥语义无关 |
| producir() / productor | 生产一个数据 / 生产者线程 | p.33 | 满则睡 buffer_no_lleno;写完叫消费者 |
| pthread_cond_wait | 原子地「放锁 + 睡」 | p.24 | 醒来要重新持有 mutex;参数必须带 mutex |
| pthread_cond_signal | 唤醒至少一个等待者 | p.24 | 没有等待者时什么也不发生(信号会丢) |
| pthread_cond_broadcast | 唤醒全部等待者 | p.24 | 西语 aviso general;小心惊群 |
| pthread_cond_timedwait | 带超时的等待 | p.24 | 第三参数是绝对时间点;超时返回 ETIMEDOUT |
| pthread_mutex_lock / trylock / unlock | 加锁 / 试加锁 / 解锁 | p.16 | 两类解锁错误:已解锁 / 被别人持有 |
| pthread_spin_lock | 自旋加锁 | p.9 | 原地空转直到成功,全程占 CPU |
| pthread_spin_trylock | 试加自旋锁 | p.9 | 失败立刻返回 EBUSY,不等待 |
| PTHREAD_COND_INITIALIZER | 条件变量的静态初始化 | p.23 | 与 pthread_cond_init 二选一 |
| PTHREAD_MUTEX_INITIALIZER | mutex 的静态初始化 | p.14 | 只能用于全局 / 静态变量 |
| pshared / process-shared | 进程共享标志 | p.15 | PRIVATE 进程内 / SHARED 跨进程(锁须在共享内存) |
| R | |||
| RCC | 条件临界区 | p.19 | region(mutex,v) when(B){S;} |
| reevaluar | 重新求值(条件) | p.26 | SIEMPRE reevaluarse;所以用 while 不用 if |
| región crítica | 临界区 | p.4 | 访问共享资源、按定义必须互斥的指令序列 |
| región crítica condicional | 条件临界区(= RCC) | p.19 | 临界区 + guarda + 条件变量 |
| S | |||
| semáforo | 信号量(本章的批评对象) | p.3 | 太底层 / 一物多用 / 小错后果不可预测 |
| señal | 信号:唤醒一个 | p.22 | 对应 signal,与 aviso general 相对 |
| siguiente() | 理发师叫号过程 | p.51 | 先举旗 signal(C1) 再等 C2——唯一「先通知后等待」 |
| sincronización | 同步:按条件协调先后 | p.19 | 不等于互斥;互斥管「不能同时」 |
| socupada | 理发椅已被占标志(silla ocupada) | p.44 | 客人坐上置 1,理发师接手后置 0 |
| spinlock | 自旋锁 | p.8 | 仅限:极短临界区 + 多核 + 等待可预测 |
| spurious wakeups | 虚假唤醒:没人 signal 也自己醒 | p.26 | POSIX 允许它发生,所以必须 while 复检 |
| struct buffer | 缓冲区结构体(最接近 monitor 的写法) | p.33 | 锁 + 两 cond + count/first/last + 数组 |
| T | |||
| timedwait | 带超时的等待 | p.24 | 超时返回 ETIMEDOUT;时间是绝对时刻 |
| trylock | 尝试加锁(不等待) | p.9 | 拿不到就 EBUSY 撤退,因此能避免死锁 |
| V | |||
| variable condición | 条件变量 | p.22 | 不保存状态,只是一条「睡觉队列」 |
| visitas (HebraVisitas) | 花园实例里的线程体 | p.18 | 它调用的 IncVsitantes 才是被锁保护的计数 |
| W | |||
| wait | 等待(cond_wait) | p.24 | 必须写在 while 里反复检查条件 |
| wesc | 在门外排队的写者数 | p.37 | 写者优先时用它拦住新读者 |
| wlec | 在门外排队的读者数 | p.37 | post_escribir 据此决定先叫谁 |
十二、考前 10 分钟速记卡
只背这一屏spinlock:原地转,烧 CPU。
mutex:睡觉等,谁锁谁解。
cond:睡在某个「条件」上,等人叫。
① menor sobrecoste(免阻塞/唤醒)
② respuesta rápida(多核)
③ evitan cambios de contexto
① 临界区极短 ② 多核 ③ 等待可预测。
单核 / 长临界区 = 纯浪费。
① init 后是 desbloqueado
② 谁锁谁解(不可跨线程)
③ destroy 前必须解锁
(cond, mutex)——放锁 + 睡是原子的;醒来要重新持锁。
醒来条件可能不成立(被别人抢先 / spurious wakeup)。
原句:SIEMPRE reevaluarse。
读×读 ✔ 读×写 ✘ 写×写 ✘。
四条条件的归属:客人等 C1/C3,理发师等 C2/C4(理发师题)。
读/写题:读者等 nesc,写者等 nesc+nlec。
PC:生产完叫消费者、消费完叫生产者。
读/写:nlec==0 才叫写者;post_escribir 先叫读者。
C1 blibre / C2 socupada
C3 pabierta / C4 pabierta(共用)+ cciclo
数「交接点」就是数条件。
Hoare + Hansen、mediados de los 70、siempre en exclusión mutua。
它只是 filosofía,不是语法。
一个等待集混着等不同条件 → signal 叫错人;broadcast 又惊群。
前提:条件可能同时成立就必须拆开。
「短路等待用自旋,长期等待用睡眠,等条件用 cond,封装成类型叫 monitor」🔐