Tema 3 · Parte 3:共享内存的通信与同步 —— Spinlock y Mutex

Comunicación y sincronización con memoria compartida. Parte 3. Spinlock y Mutex
逐句对照版 · 讲义 52 页一页不省 · 一句西语 → 一句中文 → 考点解释 · 每页附原页截图
怎么用这份讲义

一、Regiones críticas:为什么信号量还不够

p.1–p.7
p.1

Portada · 封面

▸ 原页截图 p.1原讲义第 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 部分:自旋锁与互斥量。

封面页只有一个信息值得记:这一部分是 Parte 3,主题词从「semáforo」换成了 spinlock / mutex / variable condición / monitor。考试如果问「Tema 3 讲了哪几类同步机制」,答案要能按顺序背出来:espera activa → semáforos → spinlock y mutex(含 variables condición 与 monitores)。
记忆钩子:「信号量是万能螺丝刀,spinlock 是电钻,mutex 是带保险的电动螺丝刀,monitor 是整台工具箱」——工具越往上越安全,但也越"重"🔧
p.2

Índice de contenidos · 目录

▸ 原页截图 p.2原讲义第 2 页

Índice de contenidos

目录。

Regiones críticas

临界区(语言层面的「保护区」抽象)。

Spinlocks

自旋锁(拿不到就原地空转等)。

Mutex

互斥量(拿不到就睡,让出 CPU)。

Regiones críticas condicionales

条件临界区(带 when (B) 守卫的临界区)。

Variables condición

条件变量(POSIX 里真正实现「条件临界区」的工具)。

Monitores

管程(一种把同步全部封装起来的编程「哲学」)。

这六行就是本章的六个考点模块,而且顺序就是讲义的推进逻辑:先吐槽信号量(regiones críticas)→ 两种底层锁(spinlock / mutex)→ 一个抽象(RCC)→ 它的实现(variable condición)→ 它的封装(monitor)。答题时按这个链条写,条理分直接拉满。
别把 Regiones críticas condicionales(p.19–p.21,伪代码概念)和 Variables condición(p.22–p.28,POSIX 真函数)搞混。前者是「设计思想」,后者是「实现工具」,考试问「用 POSIX 怎么实现 RCC」答的是后者。
p.3

Regiones críticas · 信号量的四宗罪

▸ 原页截图 p.3原讲义第 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 = 死锁」是本页最可能被单独考的一句话。
注意原文写的是 post-protocolo 漏 post → bloqueos(阻塞),不是「死锁」这个词。答题时照原文写 bloqueos 最稳;如果题目要你解释,再补一句「本质是永久阻塞,即死锁」。
记忆钩子:「wait 少一个 → 门没锁;post 少一个 → 钥匙丢了」——前者是安全事故,后者是把自己反锁在屋里🚪
p.4

Regiones críticas · 定义

▸ 原页截图 p.4原讲义第 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.

Una región crítica 是线程中的一段指令序列,它访问共享资源,并且按定义必须以互斥方式执行。

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。这句话就是「为什么要有临界区」的标准答案。
记忆钩子:「临界区 = 加了 VIP 门禁的房间,刷卡是语言帮你刷的,你只管进」——和信号量最大的区别就在「自动」这两个字✨
p.5

Regiones críticas · region(mutex){ S; } 伪代码

▸ 原页截图 p.5原讲义第 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;
}
这段伪代码的语法结构是 region (标识符) { 语句序列 },讲义明确标注了 pseudocódigo(伪代码)——也就是说 C 语言里没有 region 这个关键字。考试如果要你「用伪代码写一个临界区」,就照这个格式写;如果要「用 POSIX 实现」,就得换成 pthread_mutex_lock/unlock。
括号里的 mutex 在这里不是 pthread 的那个 mutex 变量,而是「这把锁的名字/标识」。名字相同的临界区互斥,名字不同的可以并行——这一点在 p.7 会被专门强调,是易错点。
p.6

Regiones críticas · 进入 / 排队 / 释放 三步

▸ 原页截图 p.6原讲义第 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
这一页给出了临界区的三步语义,也就是 p.5 那三行伪代码的「操作解释」:申请 → 执行 → 释放。请把它和 Tema 3 Parte 2 的 preprotocolo / postprotocolo 对应起来:
pido bloquear ↔ wait(mutex)
devuelvo bloqueo ↔ post(mutex)
考试常问「临界区的进入协议等价于信号量的哪几步」,答案就是这个对应关系。
还有两个容易漏的得分点:
① 拿不到锁时线程是 se bloquea(阻塞),不是忙等——这是 region 相对 spinlock 的关键区别;
② 释放后唤醒的是队列里的 la primera(第一个),这是 FIFO 语义,直接关系到后面讲的「公平性」。
记忆钩子:「排队买奶茶:扫码下单(pido)→ 做奶茶(S)→ 取走(devuelvo)」——做不了就站旁边等,别在柜台前原地转圈🧋
p.7

Regiones críticas · 同名的才互斥 + POSIX 的两个真家伙

▸ 原页截图 p.7原讲义第 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。这句话是简答题的送分点。
「Sólo ... con el mismo identificador」——这里的 sólo/mismo 是命题人最爱下手的词。如果题目说「所有临界区都互斥」,那是错的;正确说法是「同标识符的临界区互斥」。
记忆钩子:「同名锁 = 同一个厕所隔间;不同名 = 不同隔间,各锁各的」——千万别以为全楼只有一个坑位🚻

二、Spinlocks:原地空转的轻量锁

p.8–p.12
p.8

Spinlocks · 定义、代价、优点与适用场景

▸ 原页截图 p.8原讲义第 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(下一个机制)。

对比项SpinlockMutex
拿不到锁时while(locked);挂起(阻塞)线程
CPU 消耗一直占着 CPU 空转让出 CPU,不耗
唤醒开销无(本来就没睡)有(系统调用 + 上下文切换)
适合的临界区极短(几条指令)长、或时长不可预测
单核上几乎没意义(转着也进不去)正常
本页是本章最典型的简答题素材:务必能一字不差地说出 tres ventajas——① menor sobrecoste(免去阻塞/唤醒)② respuesta rápida en sistemas multinúcleo ③ evitan cambios de contexto;以及 tres condiciones de uso——① secciones críticas muy breves ② varios núcleos ③ espera predecible。
陷阱:题目若说「spinlock 比 mutex 更高效」,必须限定条件。在单核或临界区很长时,spinlock 是纯粹的浪费——你转圈的时候持有者根本没机会被调度上去。答题要写 sólo si la sección crítica es muy breve y hay varios núcleos。
记忆钩子:「spinlock = 在厕所门口原地跺脚;mutex = 拿号坐下刷手机」——跺脚只适合里面的人马上就出来(短临界区)🚻🏃
p.9

Spinlocks · 四个 POSIX 函数

▸ 原页截图 p.9原讲义第 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解锁—
考点在 trylock:它与 lock 的差别就是「不等待」——失败立刻返回 EBUSY,让线程可以先去干别的。这个非阻塞语义在避免死锁(后面 mutex 的 p.16 会再考一次)和「尝试性访问」场景里是标准答案。
别把 pshared 的取值搞混:PTHREAD_PROCESS_PRIVATE = 只在本进程的线程之间共享;PTHREAD_PROCESS_SHARED = 跨进程共享(锁必须放在共享内存里)。考试常把这两个名字当选项来设套。
记忆钩子:「init / lock / trylock / unlock = 建锁 / 死等 / 试一下就走 / 放锁」——只有 trylock 带「try」,就是「试试看,不行我撤」🙋
p.10

Ejemplo spinlock · 两个线程抢一个 contador

▸ 原页截图 p.10原讲义第 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

// 销毁自旋锁

这段代码是模板级的,背下来直接能用于编程题:全局声明 → init(检查返回值)→ create → join → destroy。注意销毁位置在 join 之后,因为必须保证没有线程还在用它。这个顺序在任何 POSIX 同步对象(mutex / cond / spinlock)上都成立,属于必背套路。
名义上是「spinlock 保护计数器」,但这里临界区只有 contador++ 一条——这正是 spinlock 唯一合理的用法。如果考试让你评价这段代码,标准答案:sección crítica muy breve ⇒ spinlock adecuado; en un solo núcleo no habría ventaja。
细节得分点:N 在这段代码里没有定义(讲义省略),真实编译要自己 #define N …;另外 pthread_spin_init 的第二个参数只影响跨进程共享,与「是否初始为未锁」无关——自旋锁初始化后恒为未锁状态。
记忆钩子:「init 检查、create 成对、join 等齐、destroy 收尾」——四步走完才算一段干净的并发程序🧹
p.11

Productor-consumidor con spinlock · main 与共享变量

▸ 原页截图 p.11原讲义第 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)各自私有
这一页的设计要点:只用一个 nelem 就能同时表达「满」和「空」两种状态——nelem == TAM_BUFFER 表示满,nelem == 0 表示空。考试常问「缓冲区满/空怎么判断」,答案就是这个单一计数器,而不是比较读写指针(那需要浪费一个格子)。
注意 buffer、nelem、lock 全是全局变量。这就是「共享内存通信」在代码层面的样子:靠全局变量共享数据,靠同步对象保护它。如果题目问「为什么不能把它们定义在 main 里」,答案是线程函数只能通过 arg 或全局访问。
记忆钩子:「一个 ring 一个数:buffer + nelem」——环形数组负责装,计数器负责说「还有几个位子」🍩
p.12

Productor / consumidor · 锁 + if 的「假同步」

▸ 原页截图 p.12原讲义第 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(输出格式串)。

这里是全章最重要的「反例」,也是考试最爱设的坑:这不叫同步,这叫「锁 + 轮询」。当 nelem == TAM_BUFFER 时,productor 拿锁 → 发现满 → if 不成立 → 解锁 → 立刻再来一遍,形成 espera activa(忙等),白白烧 CPU。真正需要的是「满了就睡,等别人叫醒我」——那就是下一节的 variable condición。
必答的两个问题:
① 为什么用 if 而不是 while?因为这里「等待」不是发生在条件判断处,而是靠外层 while(1) 反复重试;换言之 if 只是「这一次跳过」。
② 锁保护了什么?保护了 nelem 和 buffer 的一致性(读-改-写不被撕裂),但没有提供「等到条件成立」的能力。
原码小瑕疵(看原页时会发现):productor 结尾没有 return NULL;(consumidor 有)。因为 while(1) 永不退出,实际执行不到,但编译器会警告 control reaches end of non-void function。答题时照抄原样即可,别自作主张改。
记忆钩子:「spinlock 只管「别撞车」,不管「等到有车位」」——它保证互斥,不保证同步⛔🚗

三、Mutex:拿不到就睡觉的锁

p.13–p.18
p.13

Mutex · 定义、阻塞、以及「谁锁谁解」

▸ 原页截图 p.13原讲义第 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阻塞并让出 CPUsó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——括号里这句是命题人埋的送分点,几乎必考。
大坑预警:信号量的 V 操作可以由任意线程执行(所以能做「生产者发信号给消费者」这种跨线程通知);而 mutex 的 unlock 必须由持有者执行,因此 mutex 不能用来做跨线程的通知。想通这一点,你就明白为什么后面还需要 variable condición 了。
记忆钩子:「spinlock 是跺脚,mutex 是睡觉;semáforo 是谁都能按的电梯按钮」——锁得自己解,信号可以别人帮你按⬆️
p.14

Mutex · 初始化与销毁(含 INITIALIZER 快捷方式)

▸ 原页截图 p.14原讲义第 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 调用。
别把「初始化」和「加锁」搞混。初学者常见错误是 init 完就以为已经保护住了——init 只是建好锁,未上锁。真正进入临界区还要 pthread_mutex_lock。
记忆钩子:「init 建好=门开着,destroy 之前=门必须开着」——门没关才能拆门🚪
p.15

Mutex · 属性对象:类型、pshared、实时相关

▸ 原页截图 p.15原讲义第 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实现相关的默认行为不关心时用
最常考的是 RECURSIVE:同一线程可以多次加锁,但必须解锁同样次数才真正释放。场景题常这样出:「一个递归函数里要加锁,用哪种类型?」答:PTHREAD_MUTEX_RECURSIVE,否则第二次 lock 就把自己锁死了。
原文把属性写成 prioceiling——POSIX 里的标准写法是 prioceiling(priority ceiling,优先级天花板),不用改,但要知道它属于实时扩展,和本节的互斥语义无关。考试若只问「有哪些属性」,答 tipo / protocolo / prioceiling / process-shared 即可。
记忆钩子:「NORMAL 快、ERRORCHECK 查、RECURSIVE 递归、DEFAULT 随缘」——四兄弟各管一摊👨‍👩‍👦‍👦
p.16

Mutex · lock / trylock / unlock 与两类解锁错误

▸ 原页截图 p.16原讲义第 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错误(已解锁)错误(非持有者)正常释放
trylock 为什么能避免死锁?因为它不等待:拿到就干活,拿不到就返回 EBUSY 去释放自己已持有的锁、稍后重试。这就打破了「A 等 B、B 等 A」的循环等待。EBUSY 这个名字本身也是考点(Error BUSY = 忙)。
两类解锁错误必须能各说一句:① 已经解锁(ya está desbloqueado)② 被别人持有(tomado por otra hebra)。注意:这些错误只有在 ERRORCHECK 类型下才稳定报出来;NORMAL 型下是未定义行为——所以「能不能查出错误」取决于 p.15 的类型选择,两页要串起来记。
记忆钩子:「谁锁谁解,别人解=犯规」——mutex 认人,不认脸🙅‍♀️
p.17

Mutex 实例 · el problema de los jardines(main)

▸ 原页截图 p.17原讲义第 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 = 10000001,000,000
th2&visi2 = 20000002000000
th3&visi2 = 20000002000000
th4&visi2 = 20000002000000
合计7,000,000
这道题就是「计数器的竞态条件」标准范例:4 个线程同时对同一个 Visitantes 做 ++,如果不加锁,最终结果会小于 7,000,000。原因:Visitantes = Visitantes + 1 在机器层面是「读 → 加 → 写」三步,可能被打断造成丢失更新(lost update)。加锁后结果恒等于 7000000。这是必考的计算题,答案一定要能背出来。
注意 pthread_attr_init(&attr) 只初始化了线程属性(这里全用默认值),与 mutex 无关;本页没有 pthread_mutex_destroy,也没 pthread_attr_destroy——讲义省略了收尾,考试若问「这段代码有什么不规范之处」,就答这两处。
另外函数名 HebraVisitas 里的 Hebra = 线程,是西语教材的固定用法。
记忆钩子:「1 + 2 + 2 + 2 = 7 百万」——四个门,一个 100 万、三个 200 万,总共 700 万次必须一次不丢🎟️
p.18

Mutex 实例 · IncVsitantes 与 HebraVisitas

▸ 原页截图 p.18原讲义第 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:花园问题(续)。

这段代码的核心就是那三行:lock → 读-改-写 → unlock。要能解释为什么必须包住 Visitantes = Visitantes + 1 整条语句(而不是只包住 +1):因为「读」和「写」之间是可被抢占的窗口,锁必须覆盖整个「读-改-写」序列,临界区才完整。
原文笔误:函数名写成 IncVsitantes(少了个 i),正确应是 IncVisitantes。全页两处(定义 + 调用)都这么写,保持一致所以能编译。此处照原样保留并标注,做题时别照抄进正式答案。
另外 HebraVisitas 声明为 void * 却没有 return——同样是讲义省略,编译器会警告。
参数传递的细节也是考点:void *argg 收到的是 &visi1,所以要 (long *) 强转后解引用 *NumVisitas 才能拿到次数。不能直接写 (long) arg 把指针当值用——这是指针与整数混淆的经典错误。
记忆钩子:「三行护体:lock → 改 → unlock」——中间那行是命根子,前后两行是保镖🛡️

四、Regiones críticas condicionales(RCC)

p.19–p.21
p.19

RCC · mutex 不够用:隐式的忙等

▸ 原页截图 p.19原讲义第 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存放「在这个条件上睡觉」的线程
关键词 «espera activa implícita»(隐式忙等)必须背下来——它是本章的「转折点台词」。p.12 那段 spinlock 代码就是活例子:线程在不断重试 if,没有人让它睡,这就是「隐式」的忙等。而 RCC 的目标就是把它变成显式的阻塞。
注意区分两个层次:exclusión mutua 解决「不能同时进」,condición de sincronización 解决「条件不满足时不能进、要等」。mutex 只做前者,后者必须靠条件变量——这是简答题最常见的分点,别只写「加锁就行」。
记忆钩子:「mutex 管「别人别进来」,guarda 管「我还没资格进」」——一个把门,一个验票🎫
p.20

RCC · 六步执行流程(进队 → 评估 → 睡 v)

▸ 原页截图 p.20原讲义第 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(抢不到 → cola de entrada de recurso)② 持锁评估 B ③ B 真 → 执行 S ④ B 假 → 释放 mutex 并睡到 v 的队列 ⑤ 出区者释放 mutex ⑥ 另有机制唤醒 v 上的线程。
特别注意第 ④ 步的顺序:先释放 mutex,再阻塞——否则睡着时还占着锁,别人永远进不来,直接死锁。
第 ⑥ 条「algún otro mecanismo」是本页埋的伏笔:RCC 本身并不包含唤醒机制,必须由另外的东西补上——这个东西就是下一节的 pthread_cond_signal。考试若问「RCC 的缺点」,这条就是答案之一(唤醒机制不完整)。
记忆钩子:「先放手再睡」——不能抱着锁打呼噜😴🔓
p.21

RCC · Productor / Consumidor 伪代码

▸ 原页截图 p.21原讲义第 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)

条件临界区:当缓冲区非空时才进入。

对比 p.12 的 spinlock 版本,差别全在 `when` 上:
· 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)。
这些是伪代码的松散写法,考试照写概念即可,但你要看得出问题。
记忆钩子:「when 就是门口的检票员:票不对,回家睡觉,别在门口转」🎟️😴

五、Variables condición:会睡觉的条件等待

p.22–p.28
p.22

Variables condición · 定义、挂起、配 mutex、通知

▸ 原页截图 p.22原讲义第 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 的西语叫法。
大坑:条件变量本身不保存状态!它只是一条「睡觉的队列」。条件本身存在 nelem 这种普通变量里。如果你在 signal 之后才去 wait,那个信号就丢了(notificación perdida)。所以 wait 必须写在 while 循环里反复检查——这就是 p.26 的核心。
记忆钩子:「cond 是床,mutex 是门,条件是体温计」——床不记体温,只负责让你躺下😴🌡️
p.23

Variables condición · 初始化与销毁

▸ 原页截图 p.23原讲义第 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);
三个 API 与 mutex 的对应关系是完全同构的,记住一个就会三个:
pthread_mutex_init ↔ pthread_cond_init
pthread_mutex_destroy ↔ pthread_cond_destroy
PTHREAD_MUTEX_INITIALIZER ↔ PTHREAD_COND_INITIALIZER
考试喜欢用这种「对称性」出填空题。
销毁的前置条件比 mutex 更严格:不仅「没有线程在等」,还要「没有线程将要用」。如果还有线程卡在 pthread_cond_wait 上就 destroy,属于未定义行为,程序可能直接崩。
记忆钩子:「先 join 齐,再 destroy 掉」——人走光了才能拆床🛏️
p.24

Variables condición · wait / signal / broadcast / timedwait

▸ 原页截图 p.24原讲义第 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
最核心的考点是 pthread_cond_wait 的两个参数(cond + mutex)以及它的原子性:「释放 mutex」和「进入睡眠」是一个不可分割的动作。如果不原子,就会出现「刚放手、还没睡,别人就 signal 了」的丢信号窗口。这一句是本章最高频的简答句。
为什么每个 wait 都要传 mutex?因为条件必须在锁保护下检查,否则读到的 nelem 可能是撕裂的旧值。另外 timedwait 的时间是 abstime(绝对时间点,不是时长)——这是超时类题目的固定坑。
记忆钩子:「wait 一只手放锁,另一只手关灯,同一个动作」——原子操作,中间不插队💡
p.25

Variables condición · POSIX 六步运作流程

▸ 原页截图 p.25原讲义第 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?
1lock否 → 是
2检查条件是(必须)
3条件真 → 干活 → unlock是 → 否
4条件假 → 放锁 + 睡是 → 否
5别人改状态后 signal是 / 否皆可
6醒来 → 重新 lock → 回到 2否 → 是
这一步流程就是 while (!cond) pthread_cond_wait(&c, &m); 的逐字展开。第 6 步的「vuelve a 3」画成了一个循环——这个循环箭头是本章的灵魂,也正是为什么代码里必须写 while 而不是 if。
第 5 步 「se produzca un cambio ... se deberá producir una llamada」——注意 cambio(真实改变状态)和 llamada(调 signal)是两件事:必须真的改了 nelem 等变量,signal 才有意义;单纯调 signal 而不改状态,醒来后条件仍是假,线程又睡回去(这就是 p.26 的 spurious wakeup 情形)。
记忆钩子:「锁 → 看 → 睡 → 被叫 → 再锁 → 再看」——六步一个循环,像查体温查了三次才发现没发烧🌡️🔁
p.26

Variables condición · SIEMPRE reevaluar + spurious wakeups

▸ 原页截图 p.26原讲义第 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(...)正确醒来后重新检查,仍为假则继续睡
本页是整章必考 Top 3之一,两个答案:
① 为什么用 while 不用 if:因为醒来后条件可能不成立(别人抢先、或虚假唤醒)。
② 什么是 spurious wakeup:没有被 signal 也自己醒了——POSIX 允许实现这样做,程序必须能容忍。
背下这句西语原句:SIEMPRE tiene que reevaluarse la condición。
注意 hebra2 的顺序:先改 micondicion,再 signal,再 unlock。如果先 signal 后改条件,被唤醒的线程可能读到旧值又睡回去。另外 signal 在持锁时调用是安全但非必需的(POSIX 允许不持锁调用 signal);持锁调用的好处是避免「刚 signal 完、等待者还没醒,状态又被人改掉」的竞态。
原页写的是 pseudocódigo,但这里其实是可以直接编译的 POSIX C。另外 …duerme… 这句注释位置容易误解:真正「睡」发生在 while 循环里的 cond_wait,循环外的 …duerme… 只是讲义标注「这里等过了」。
记忆钩子:「醒了不算数,再看一眼才算」——while 是保险带,if 是自杀式跳跃🎢
p.27

PC con variables condición · 全局变量与 main

▸ 原页截图 p.27原讲义第 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

用条件变量实现的生产者—消费者。

全局变量类型含义
mutexpthread_mutex_t保护全部共享状态
puedo_producirpthread_cond_t「可以生产」的等待队列
puedo_consumirpthread_cond_t「可以消费」的等待队列
buffer[N]int[10]环形缓冲区
nelemint当前元素数
jint生产者的写指针
iint消费者的读指针
本页最关键的设计是两个条件变量:puedo_producir(等「有空位」)和 puedo_consumir(等「有数据」)。为什么不能用同一个?因为生产者等的是「不满」、消费者等的是「不空」,两个条件不同,混在一条队列里会导致 signal 叫醒错的人——这一点 p.35 会专门展开。
命名是「从等待者视角」命名的:puedo_producir = 「我(生产者)现在可以生产了」。别反过来理解成「生产完了通知别人」。这种「等待条件」命名法是并发编程的标准习惯,考试答题也建议照用。
记忆钩子:「两条队:一条等空位,一条等货」——厨师等空盘,客人等上菜🍽️
p.28

PC con variables condición · Productor / Consumidor

▸ 原页截图 p.28原讲义第 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);
  }
}
两段代码镜像对称,背下这段就掌握了本章 70% 的编程题模板:
lock → while(条件不满足) wait → 改状态 → signal(对方) → unlock。
注意 signal 放的位置:在 unlock 之前、在改完状态之后。改状态在前保证被唤醒者看到的是新值;signal 在解锁前是常见的安全写法。
三个「必须」:
① 必须是 while (nelem == N),不能写 if(虚假唤醒);
② wait 的第二个参数必须是同一把 mutex;
③ 两个不同的条件变量不能混用。
违反任一条,程序在半数情况下「看起来能跑」,但在压力测试下必挂——这正是考卷爱出的「看似正确」的代码。
这里的 printf 故意放在 unlock 之后:(脱离临界区)I/O 慢,放在锁里会拖长临界区。这是一个细节得分点:临界区要尽量短。
记忆钩子:「满了等空位,空了等货;改完就叫人」——五步口诀:锁 / 等 / 改 / 叫 / 放🔔

六、Monitores:把同步封装进类型里

p.29–p.31
p.29

Monitores · 对 RCC 的三条批评

▸ 原页截图 p.29原讲义第 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访问代码分散在各线程中安全性差,谁都能改
这三条批评是「为什么要引入 monitor」的论证链,简答题常这样问:「RCC 有什么缺点?」标准答案就是这三点,并且要能说出第 3 点带出的结论——应该把访问代码集中封装起来,这就直接引出了 monitor。
注意第 2 点的逻辑:不是「做不到」,而是「即使做了也有障碍」(variables locales 不可见)。答题时写「muchas veces」(很多时候)而不是绝对的「不可能」,才符合原文语气,也显得你读懂了。
记忆钩子:「慢、瞎、散」——RCC 三宗罪:效率慢、看不清别人的变量、代码散得到处都是🕵️
p.30

Monitores · Hoare & Hansen 的定义

▸ 原页截图 p.30原讲义第 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
三个必背名词/年份:Hoare、Hansen、mediados de los 70。以及本页最常考的一句:「所有导出的过程都siempre在互斥下执行」——注意 siempre(总是),不是「可以配置」。这正是 monitor 相比 mutex 的最大优势:互斥是内建的,写代码的人不会忘。
别被最后一句误导成「monitor 已经过时」。原文说的是「没有专门的语法构造」,但思想仍在用——Java 的 synchronized、C# 的 lock、Python 的 threading.Condition 都是 monitor 哲学的实现。答题时写「es una filosofía, no una construcción」最地道。
记忆钩子:「Hoare + Hansen,70 年代,封装一切」——像把厨房整个封起来,只留一个窗口点单🍳
p.31

Monitores · 作为「概念」的价值

▸ 原页截图 p.31原讲义第 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

这样一来就不会忘记解锁互斥区。

一句话总结本页:monitor 的价值 = 「结构上让人不可能忘记解锁」。对比 mutex:手写 lock/unlock 时,只要有一条 return 或 break 漏掉 unlock,就永久死锁;而 monitor 把互斥内建在过程入口/出口,编译器帮你进出。这就是「no se olvidan desbloquear」的真正含义。
答题时区分两件事:monitor 提供「互斥」是自动的,但「条件等待」仍需显式调用 wait/signal(在 Java 里就是 await/signal)。不要说成「monitor 一切自动」——那是过度简化,会被扣分。
记忆钩子:「进出门自动上锁,忘了算我输」——monitor 是带自动门禁的房间🚪🔒

七、Productor-consumidor con buffer acotado

p.32–p.35
p.32

Buffer acotado · 问题描述与三条性质

▸ 原页截图 p.32原讲义第 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 mutuapthread_mutex_t
② 满不能写condición de sincronizacióncond buffer_no_lleno
③ 空不能取condición de sincronizacióncond buffer_no_vacio
这三条性质是全章的问题定义模板,几乎每道并发题都从这里出发。答题时先写这三条,再对应到「一把 mutex + 两个条件变量」,分数就稳了。注意性质①②③分别对应「互斥」与「同步」两类需求——这正是 p.19 说的「同步原语要同时解决两件事」的具体化。
别漏掉「en exclusión mutua」这个限定:如果只做②③而不做①,两个生产者可能同时算出同一个空位,结果互相覆盖(丢失数据)。互斥是同步的前提,不是可选项。
记忆钩子:「一个人进、满了不写、空了不取」——三条铁律,缺一条就翻车🚦
p.33

Buffer acotado · struct buffer + producir()

▸ 原页截图 p.33原讲义第 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]存放数据的数组
这是本章唯一把「数据 + 锁 + 条件」封装成 struct 的版本,也是最接近 monitor 思想的写法:结构体 = 被封装的资源,producir/consumir = 导出的过程。考试若问「用 C 怎么模拟 monitor」,答案就是这个 typedef struct 三件套。
注意 p.27 的版本用全局变量 + i/j,本页改成结构体 + 三个字段(count/first/last)。两种写法都要认得,但不要混着写:一旦选了 struct 版本,就不能再出现全局的 nelem。
另外注意 first/last 与 p.28 的 i/j 是同一对东西,只是改名了。
记忆钩子:「一个箱子:锁 + 两床 + 计数器 + 读指针 + 写指针」——箱子本身就是 monitor📦
p.34

Buffer acotado · consumir() 与 inicializar()

▸ 原页截图 p.34原讲义第 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 与条件变量 */

对比producirconsumir
等待条件count == BUFF_SIZEcount == 0
等待的 condbuffer_no_llenobuffer_no_vacio
signal 对象buffer_no_vaciobuffer_no_lleno
更新的指针lastfirst
最容易被考倒的是「signal 的对象是对方」:生产者生产完要叫消费者(signal(buffer_no_vacio)),消费者取完要叫生产者(signal(buffer_no_lleno))。很多人写反了还觉得通顺——记住:signal 发给「我刚让谁有条件继续」的人。
inicializar 是空壳(讲义省略实现),真实代码里必须做三件事:pthread_mutex_init(&B->mutex,NULL)、两个 pthread_cond_init、count = first = last = 0。尤其是 count 必须清零,否则初值随机,程序行为完全不可预测——这是考试改错题的经典素材。
记忆钩子:「生产完叫消费者,消费完叫生产者」——互相叫,别自叫🔔🔔
p.35

只有一个等待集的问题 · 为什么要多个 cond

▸ 原页截图 p.35原讲义第 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,正是因为「满」和「空」不可能同时成立。
注意原文的措辞是「no puede suponer」(不能假设)——这与 p.26 的 SIEMPRE reevaluarse 是同一个道理的两种表述。答题时如果只写「要用 while」,只能拿一半分;补上「因为唤醒不保证条件成立(含广播误醒)」才是完整答案。
记忆钩子:「一个候诊室混着看牙和看眼,护士一喊全醒」——所以要分科室排队🏥

八、Lectores / escritores:多读者可并发,写者独占

p.36–p.40
p.36

Lectores / escritores · 两条同步条件与三种组合

▸ 原页截图 p.36原讲义第 36 页

El problema de los lectores/escritores

读者 / 写者问题。

Dos tipos de hebras (tipos lector y escritor) comparten un recurso (típicamente una Base de Datos)

两类线程(lector 型与 escritor 型)共享同一个资源(通常是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

– 每个写者必须以互斥方式访问数据库,与任何其他读者线程或写者线程都en exclusión mutua。

原页插图(p.36):5 个读者线程 lector1 … lector5 和 2 个写者线程 escritor1 / escritor2,所有箭头都指向同一个 BD 方块——长的完全一样,区别只在于「能不能同时进去」。
组合能并发吗依据(原文)
读者 × 读者✔ 能条件① varios lectores … simultáneamente
读者 × 写者✘ 不能条件② 写者与任何其他线程互斥
写者 × 写者✘ 不能条件② 写者本身也算 cualquier otra hebra
这张表就是本节的标准答案骨架:读者—读者可并发,其余两两全互斥。考试若给你一段交错序列让你判断「是否合法」,不用想算法,按这三行逐对检查就行——只要出现「写者与任何线程同时在区里」,直接判非法。
最容易漏的是第三行「写者 × 写者」。很多人只记得「读写互斥」,忘了写者之间也必须互斥——因为写者会改数据,两个写者同时改就是经典的丢失更新(lost update)。
记忆钩子:「读者像围着一本书看的人,可以一群人同看;写者像编辑,改稿时谁都不许看👀✍️」
p.37

main 骨架 · 四个计数器 + 两把 cond

▸ 原页截图 p.37原讲义第 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
记牢这套算法的全部状态只有四个 int:n = 正在里面的人,w = 在门外排队的人。凡是 n 都不配条件变量(它只是计数);w 的唯一用处是「决定该叫谁」。这条规律在读者/写者、理发师、PC 里全都成立,是本章通用套路。
两个坑:① pthread_join(esc[0], NULL) 只等了第一个写者,读者和其他写者都没等——讲义是示意写法,严格说主线程会直接结束;② 两个 for 复用同一个 i 在这里没问题(顺序执行完第一个循环才进第二个),别和 p.21 伪代码里「并发区共用 i」的 bug 混为一谈。
记忆钩子:「4 个计数器(2 里面 + 2 门外)、1 把锁、2 间候诊室」——N=inside,W=waiting,n 不算锁,w 只管叫号🪑
p.38

三段式 · pre / 操作 / post(这正是 monitor 的主张)

▸ 原页截图 p.38原讲义第 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)
escritorespre_escribir()escribir()post_escribir()
lectorespre_leer()leer()post_leer()
谁负责加解锁pre 负责 lock + 可能 wait;post 负责更新计数 + signal + unlock——线程体本身一行锁都不用写
这是本章最重要的设计套路,考试常问「为什么要把同步写成 pre/post 函数?」标准三点:
① 分离关注点——业务代码 leer() / escribir() 里看不到任何 mutex,干净;
② 复用与不漏——所有线程走同一条路径,不会有人忘了 unlock;
③ 向 monitor 过渡——原文这句「tal y como proponen los monitores」就是在暗示:pre/post 再封装一层,就是管程。
注意 while(1) 是死循环、arg 完全没用——这两点原文都没处理。答题时不要照抄成「一段完整可运行的程序」,它只是结构示意。
记忆钩子:「进门排队(pre)→ 办事 → 交班放号(post)」——业务函数两手空空,锁全在门卫手里🚪
p.39

pre_leer / post_leer · 读者的登记与「接力棒」

▸ 原页截图 p.39原讲义第 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,让读者们真正并行读读者之间不互斥,所以可以同时在里面
「为什么 signal 只叫一个,却能让所有等待读者都进去?」——这是本节的王牌考点。答案是接力棒效应(cascada):每个被叫醒的读者在 nlec++ 之后都会再 signal 一次 cond_lec,于是「醒一个 → 它叫下一个 → 再叫下一个……」,形成连锁。所以不需要 broadcast。
同理看 post_leer:只有 nlec == 0(最后一个读者离开)时才 signal(&cond_esc)——因为写者之间互斥,叫一个就够。
原文这里有两处排版笔误:wlec—-; 与 nlec—-; 中的 —- 是破折号,C 语言里应为双减号 --。抄到卷子上照抄直接编译不过,这里已用红底标出。
另外:若把 while 写成 if,遇到虚假唤醒(p.26)就会在写者仍在写的时候闯进去——必扣分。
记忆钩子:「走一个回头喊一声,后面一串全跟上」——这就是 signal 的接力,不用广播📣
p.40

pre_escribir / post_escribir · 为什么这套算法是「读者优先」

▸ 原页截图 p.40原讲义第 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_leerwhile (nesc > 0)while ((nesc > 0) || (wesc > 0))
post_escribirif (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 这个计数器就基本没用了。
原文 ¿Como se daría… 少了重音符,规范写法是 ¿Cómo(疑问词带重音)。这是讲义排版的小疏漏,考试写作时千万别跟着漏——在写作模块里,疑问词漏重音是明确的扣分项。
记忆钩子:「谁先被叫号,谁就有优先权」——想换人优先,只改「门口查什么」和「出门先喊谁」这两处🎫

九、El barbero dormilón:四条同步条件与一个锁

p.41–p.51
p.41

El barbero dormilón · 场景设定(两扇门、一把椅子、一排等候椅)

▸ 原页截图 p.41原讲义第 41 页

El problema del barbero dormilón

睡眠理发师问题(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.41):左边 entrada(入口门),中间 barbero 与 cliente(理发椅上的那一位),右边一列 Cliente esperando …(等候椅),最右边 salida(出口门)。两扇门是分开的——这正是后文要用两条独立条件(C3 开门 / C4 关门)的原因,别把进出门画成一个。
本页只是场景,但它已经把后面所有代码的「角色」定好了:1 个理发师线程 + N 个客人线程 + 1 把互斥锁 + 4 个布尔标志。考试若要求你「先描述问题再建模」,就按这句骨架写:「两类线程共享一间店,店里有三处可占用位置(理发椅、等候椅、门),每处都要互斥且要等待对方」。
原文 sino 是拼写错误,应为 si no(= 「如果不这样」,两个词)。sino 连写是「而是」的意思(no A sino B),两者意思完全不同,这是写作模块的高频扣分点,记住别混。
记忆钩子:「两门一椅一排座,理发师闲了就睡😴💈」——店小、资源少、全靠「叫醒」串起来。
p.42

执行序列 · 为什么恰好是四条同步条件

▸ 原页截图 p.42原讲义第 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:

因此,我们一共有四条同步条件:

#步骤(西语)中文谁在等谁
1barbero disponible理发师空闲起点:blibre = 1
2nuevo cliente se sienta en la silla新客人坐上理发椅客人等理发师 → C1
3barbero pela cliente理发师开始剪理发师等客人坐好 → C2
4barbero abre la puerta de salida理发师打开出口门客人等门开 → C3
5cliente se va, cierra la puerta客人离开并关门理发师等门关 → C4
6barbero disponible理发师回到空闲循环回到 1
「为什么是四条?」是本节的标准问法。答案不是背数字,而是数「交接点」:这条链上有 4 处「一方必须等另一方」的交接——① 客人等空闲、② 理发师等坐好、③ 客人等开门、④ 理发师等关门。每个交接点 = 一个布尔标志 + 一个条件变量。数交接点,就是数条件,这条方法在大题里能稳定拿分。
注意第 5 步的动作主体换了:开门的是理发师,关门的却是客人(原文 que es cerrada por el cliente que sale)。所以 C4 是「理发师等客人关门」,不是「客人等理发师关门」——方向搞反,整段代码就倒过来了。
记忆钩子:「空闲 → 坐下 → 剪 → 开门 → 关门 → 空闲」——六步一条环,四个卡口各配一把「旗子」🔁
p.43

C1 · 理发师不空闲,新客人不许坐下

▸ 原页截图 p.43原讲义第 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 的两个变量名字含义谁写它谁读它
blibrebarbero libre = 理发师空闲理发师(下班时置 1);客人坐上后置 0客人
cblibrecondition blibre = 「等理发师空闲」的候诊室signal客人 cond_wait
命名法是送分点也是扣分点:这套代码里所有条件变量都是 c + 布尔名(cblibre / csocupada / cpabierta / cciclo)。考试让你写代码时,只要保持「一布尔配一 c-cond」的对应关系,阅卷一眼就能看懂,比乱取名稳。反过来,若你写 cond1/cond2,通常会被扣「可读性」分。
⚠️ 原文这里有语法错误:hasta que el barbero no está disponible 用的是陈述式 está,但 hasta que 指向尚未发生的将来,必须用虚拟式 esté——下一版 p.44 就改成了 no esté。
另外这句是西语典型的冗余否定:no … hasta que no … 两个 no 意思仍是肯定(「直到…才…」),不是双重否定。写作模块里照这个语感写才地道,但别漏了虚拟式。
记忆钩子:「椅子是理发师的,他说 free 你才能坐」——blibre = 0 时客人只能在门外排队💈
p.44

C2 · 客人没坐好,理发师不许动剪刀

▸ 原页截图 p.44原讲义第 44 页
本页顶部逐字重复 p.42–p.43 的引入段(Ejecución del sistema 六步链 + cuatro condiciones)以及 C1(仅把 no está 修正为 no esté,见 p.43)。译文不再重复,本页新增内容如下。

– 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 的两个变量名字含义谁写它谁读它
socupadasilla ocupada = 理发椅已被占客人坐上后置 1;理发师接手后置 0理发师
csocupada「等椅子被占」的候诊室signal理发师 cond_wait
C1 与 C2 是一对「握手」,方向正好相反:
· C1 = 客人等理发师(blibre)
· C2 = 理发师等客人(socupada)
考试最爱考的就是问「C1 和 C2 分别是谁等谁」。判读口诀:看句子主语谁「不动」——不动的那一方就是等待方(C1 里 un nuevo cliente no se sienta → 客人等;C2 里 el barbero no pela → 理发师等)。
C2 里用的是完成体 no se ha sentado(现在完成时),强调「已经坐好了」这个结果,而不是「正在坐」的过程。若改成 no se sienta,语义就变成「不坐下」——时态一换,条件含义就变了,这是语法题和代码题都喜欢设置的陷阱。
记忆钩子:「客人屁股不落椅,剪刀不许响✂️」——C2 是理发师在等,别和 C1 搞反。
p.45

C3 · 理发师不开门,客人不许走

▸ 原页截图 p.45原讲义第 45 页
本页顶部继续逐字重复引入段与 C1、C2(译文见 p.42–p.44)。新增只有 C3。

– 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 的两个变量名字含义谁写它谁读它
pabiertapuerta abierta = 出口门已打开理发师剪完置 1;客人离开后置 0客人
cpabierta「等门打开」的候诊室signal客人 cond_wait
C3 是第二个「客人等理发师」(第一个是 C1)。所以四条条件的归属是:
客人等 → C1(等空闲)、C3(等开门);理发师等 → C2(等坐好)、C4(等关门)。
这个 2 vs 2 的对称结构背下来,后面 cortar() 与 finpelar() 的代码就自然分得清:cortar 里等 C1 和 C3,finpelar 里等 C4,siguiente 里等 C2。
这里同样有冗余否定 no … hasta que no …,仍表示肯定含义。另外注意 le ha abierto 用了与格代词 le(「给他」开门)——西语里「替某人/对某人做某事」必须带与格,漏掉 le 是写作高频小错。
记忆钩子:「门没开,客人钉在椅子上;门一开,客人才能溜」🚪
p.46

C4 · 客人没关门,理发师不算空闲(含原文笔误)

▸ 原页截图 p.46原讲义第 46 页
本页顶部重复引入段与 C1、C2、C3(译文见 p.42–p.45)。C2 的声明在本页被改写了一次:var socupada:boolean; csocupada:condition,见下方 warn。新增只有 C4。

– C4: El barbero no está disponible hasta que el cliente ha cerrado la puerta (boolean pabierta; condition cciclo)

– C4:客人把门关上之前,理发师都「不算空闲」 ——(boolean pabierta; condition cciclo)。

#条件(西语)中文布尔cond谁等
C1cliente no se sienta hasta que barbero libre理发师不空闲,客人不坐blibrecblibre客人
C2barbero no pela hasta que cliente sentado客人没坐好,理发师不剪socupadacsocupada理发师
C3cliente no se va hasta que puerta abierta门没开,客人不走pabiertacpabierta客人
C4barbero 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 里没有它,属于排版没统一。
考「四条条件能不能合并成一个布尔」的题型:能合并的唯一前提是「两个条件不可能同时为真」(p.35 的结论)。C3 与 C4 正是这种互斥对——门要么开着等客人走,要么关着等理发师开工,不会同时为真,所以共用 pabierta 是安全的。但若两条条件可能同时为真,共用就会互相污染,必须拆开。判题口诀:先问「能不能同时成立」,再决定合不合。
记忆钩子:「一扇门只用一面旗:开着 1、关着 0」——旗子在客人手里放倒,理发师才开工🚩
p.47

真实代码 · 全局变量、四个 cond 与 main

▸ 原页截图 p.47原讲义第 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
thbar1 个理发师线程Barbero()
th[MAXI]50 个客人线程cliente()
id[MAXI]给每个客人一个编号&id[i] 传给线程
本页最大的考点是条件的两种初始化方式:这里用静态初始化宏 PTHREAD_COND_INITIALIZER(全局变量、编译期就绪),而 p.23 用的是动态初始化 pthread_cond_init(&c, NULL)(运行期调用)。规则:全局/静态的用宏,动态分配或需要属性的用函数;混着用不会报错,但考试问「两种初始化有什么区别」必须答得出。用了宏就不要再调 cond_init,重复初始化是未定义行为。
三个细节:① pthread_attr_t attr 初始化了但没设任何属性(等价于默认),纯粹照抄模板;② pthread_join(th[0], NULL) 只等 0 号客人,其余 49 个和理发师都没等——和 p.37 一样的示意写法;③ id[i] 是数组元素地址传给新线程,只要数组不销毁就安全,但别写成 &i(那样 50 个线程会读到同一个会变的 i,经典 bug)。
记忆钩子:「1 个理发师 + 50 个客人 + 1 把锁 + 4 面旗」——旗子全是 0 起步:没人、门关、椅子空💈
p.48

Barbero() 与 cliente() · 线程体只调用「monitor 函数」

▸ 原页截图 p.48原讲义第 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"); → 打印「正在剪」。

线程循环体谁在等
Barberosiguiente() → sleep(1) → printf → finpelar()siguiente 里等 C2;finpelar 里等 C4
clientecortar(id) → sleep(2)cortar 里等 C1、C3
原文三处注释 // función del monitor 是本章的落点:siguiente / finpelar / cortar 这三个函数就是 monitor 的「过程(procedures)」——它们内部拿锁、判断条件、等待、通知、放锁;线程体只负责调用,完全看不见 mutex。这与 p.38 的 pre/post 是同一思想,只是这里连业务动作(剪、走、叫号)也一起封装进去了。
考「为什么说这段代码体现了 monitor」→ 就答:同步与操作被合并封装进函数,调用者不接触任何同步原语。
sleep(1) / sleep(2) 只是模拟耗时(剪发要 1 秒),它们不参与同步,别误以为靠 sleep 排序——真实并发里顺序完全由 mutex/cond 决定。
另外 id = *((int *) arg); 是标准的「从 void * 取回 int」写法:先转 int * 再解引用,括号少一个都是语法错。
记忆钩子:「线程体是空壳,真功夫全在三个函数里」——这就是 monitor 的壳与核🥚
p.49

cortar(id) · 客人端:两次等待、两次放行

▸ 原页截图 p.49原讲义第 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)理发师不空闲就睡在 cblibreC1(客人等)
blibre = 0占了理发师 → 他不再空闲C1 的另一半
socupada = 1坐上椅子 → 椅子被占C2 的前半
signal(&csocupada)叫醒理发师:可以剪了C2 的通知
while (!pabierta) wait(cpabierta)门没开就睡在 cpabiertaC3(客人等)
pabierta = 0把门关回去 → 门不再「开着」C4 的前半
signal(&cciclo)叫醒理发师:我关好门了C4 的通知
unlock(&m)出门放锁—
这个函数是整章最值得逐行背的 15 行,因为它的结构可以套到任何「等两次、放两次」的场景:
① wait 用 while (!条件);② 醒来先「把自己那一侧的旗子改掉」;③ 改完立刻 signal 对方;④ 最后 unlock。
特别注意「客人关门」这个动作:pabierta = 0 是客人写、理发师读——旗子由谁改、由谁等,必须和 p.42 的交接点一一对上,写反就是死锁。
两处语法细节:① 两个 while 后面都没有花括号(只有一条语句),原文就是这么写的,能编译,但一旦你想加第二行语句就会掉进坑——建议答题时补上 { };② while (!blibre) 里的 ! 是逻辑非,读作「只要 blibre 为假」——别读成「只要不空闲」,正好相反:!blibre 为真 = 理发师不空闲。
记忆钩子:「想剪 → 等空闲 → 占椅叫号 → 等开门 → 关门叫号 → 走人」——客人一生就走这一趟🚶‍♂️
p.50

finpelar() · 理发师端:开门之后还要等门关

▸ 原页截图 p.50原讲义第 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)放锁服务周期闭合
最典型的考点在第 5 行:为什么是 while (pabierta) 而不是 while (!pabierta)?
因为这里等的是「门关掉」——只要门还开着(pabierta == 1),理发师就得继续等;等客人执行 pabierta = 0 并 signal(&cciclo) 之后,循环条件为假,理发师才继续。
一句话:while 里写的是「继续睡的条件」,不是「醒来的条件」——这是全章最容易翻车的一处极性错误。
如果去掉这个 while(开完门直接返回),理发师会立刻进入下一轮 siguiente(),而此时门还没关、客人还在店里——C4 被破坏:两个线程同时在「服务区」里。如果把 while 写成 if,遇到虚假唤醒就会提前放行,同样破坏 C4。
记忆钩子:「理发师开门 → 必须亲眼看见门关上才接下一个」——不看门就接客,店里会撞车🚪👀
p.51

siguiente() · 理发师叫号:先举旗,再睡觉

▸ 原页截图 p.51原讲义第 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)放锁,开始剪—
本页是「一个函数里既有通知又有等待」的唯一例子,也是最好考的一处:理发师先 signal 别人,然后自己 wait——顺序绝不能颠倒。
· 若先 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)
三个函数合起来只有 1 把锁 m,却撑起四条条件——这就是「mutex + 多个 cond」的标准形态:锁只有一个(保护共享状态),等待集可以有多个(按条件分流)。若只用一个 cond 会怎样?回到 p.35 的结论:signal 可能叫错人,只能改用 broadcast 全叫醒,效率暴跌。
记忆钩子:「先把『我空了』的牌子挂出去,再躺下等人坐上来」——牌子先挂,人后睡🪧😴

十、En resumen:全章三条主线

p.52
p.52

En resumen · 全章三条主线

▸ 原页截图 p.52原讲义第 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 需手工模拟)
本章考法就三条主线,背这三句就能覆盖 80% 的问答题:
① 「什么时候用 spinlock?」→ 等待极短 + 临界区极小 + 多处理器(p.8 三条件)。
② 「mutex 与条件变量的分工?」→ mutex 管「谁能进」,cond 管「什么时候能进」;锁只有一个,等待集可以有多个(p.35)。
③ 「monitor 好在哪?」→ 把同步封装进类型/过程,调用者不碰同步原语;代价是条件循环仍需掌握(原文这个 inconveniente 就是在提醒你别以为用了 monitor 就万事大吉)。
注意原文这个 inconveniente(缺点)是扣分点也是送分点:很多同学只夸 mutex+cond「高级、结构化」,答不出缺点就丢一半分。标准答法:「程序员仍需自己写 while 复检条件,容易漏掉 signal 或把 while 写成 if」——正好呼应 p.26 的 SIEMPRE reevaluarse。
记忆钩子:「短路等待用自旋,长期等待用睡眠,等条件用 cond,封装成类型叫 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阻塞:挂起并让出 CPUp.13正面对比 spinlock 的「原地空转」
broadcast唤醒全部等待者p.24只有当多条条件可能同时成立时才需要它
buffer acotado有界缓冲区p.32三条性质:互斥 / 满不写 / 空不取
BUFF_SIZE缓冲区容量常量p.33count == BUFF_SIZE 就是「满」
C
cblibre「等理发师空闲」的等待集p.43命名法:c + 布尔名,一布尔配一 cond
cciclo「等门关上」的等待集(C4)p.46C3 与 C4 共用 pabierta,但 cond 分开
ceder la CPU让出 CPU(交给别的线程)p.13mutex 阻塞时会做,spinlock 绝不会做
cliente客人线程p.41叫醒理发师 → 坐下 → 等开门 → 关门离开
cola de entrada入口队列p.20RCC 里抢不到 mutex 就排在这里
conjunto de espera等待集(一个 cond 就是一个「候诊室」)p.35混着等不同条件,signal 就会叫错人
condición de sincronización同步条件p.19mutex 管「不能同时」,它管「必须等到」
consumidor消费者线程p.32空不能取;取完叫生产者
contador计数器(并发竞态的最小例子)p.10两个线程同时 ++ 就会丢更新
cortar(id)客人端过程:坐下到离开p.49等 C1 → 坐好通知 → 等 C3 → 关门通知
cpabierta「等门打开」的等待集(C3)p.45睡在这里的是客人,不是理发师
csocupada「等椅子被占」的等待集(C2)p.44睡在这里的是理发师
D
deadlock死锁(= interbloqueo)p.16trylock 不等待 ⇒ 可打破循环等待
desbloqueado未加锁状态p.14init 之后就是它;destroy 之前必须回到它
despertar唤醒p.24先改共享状态,再 signal,顺序不能反
destruir销毁(destroy)p.14mutex 要解锁才能销毁;cond 要没人等才能销毁
dormilón困倦的(barbero dormilón)p.41没人就睡,来人就被叫醒——「睡」是状态不是忙等
E
EBUSY资源忙(错误码)p.9trylock 拿不到就返回它,绝不阻塞
encapsular封装p.30monitor 把「资源 + 所有同步方面」包进类型
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.3070 年代中期;导出过程始终互斥
I
implícita隐式的p.19隐式忙等:没人让你睡,是你自己在转
inanición饥饿(starvation)p.40读者优先 ⇒ 写者可能永远轮不到
IncVsitantes原文拼写(应为 IncrementarVisitantes)p.18原文笔误,照抄会编译不过
inicializar初始化p.34count = 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.16NORMAL 型重复 lock ⇒ 把自己锁死
M
main主函数:建线程、初始化锁与 condp.37只 join(esc[0]) 是示意写法,别当标准答案
MAXI理发店最大客数(50)p.47#define MAXI 50 ⇒ 50 客人 + 1 理发师
monitor管程 / 监视器p.30资源 + 同步全封装;导出过程天生互斥
mutex互斥量p.13拿不到就睡;谁锁谁解,不能跨线程通知
mutexattrmutex 属性对象p.15类型 / process-shared / 实时属性三组
N
nesc正在里面写的写者数(0 或 1)p.37nesc > 0 时读者必须等
nlec正在里面读的读者数p.37只有 nlec == 0 才通知写者
NORMAL / ERRORCHECK / RECURSIVE / DEFAULTmutex 的四种类型p.15RECURSIVE 可重复加锁,但解锁次数要一样多
P
pabierta出口门已打开标志(puerta abierta)p.45C3/C4 共用:门要么开要么关,不会同时
pelar剪(头发)p.41el barbero pela al cliente
POSIX可移植操作系统接口标准p.7临界区的真实实现只有 Mutex 与 Spinlock
pre_escribir / post_escribir写者的进 / 出协议p.40出门先叫读者 ⇒ 这套算法是读者优先
pre_leer / post_leer读者的进 / 出协议p.39signal 接力棒,不需要 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_INITIALIZERmutex 的静态初始化p.14只能用于全局 / 静态变量
pshared / process-shared进程共享标志p.15PRIVATE 进程内 / SHARED 跨进程(锁须在共享内存)
R
RCC条件临界区p.19region(mutex,v) when(B){S;}
reevaluar重新求值(条件)p.26SIEMPRE 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.26POSIX 允许它发生,所以必须 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.37post_escribir 据此决定先叫谁

十二、考前 10 分钟速记卡

只背这一屏
三种锁 · 一句话分辨
spinlock:原地转,烧 CPU。
mutex:睡觉等,谁锁谁解。
cond:睡在某个「条件」上,等人叫。
spinlock · 三优点
① menor sobrecoste(免阻塞/唤醒)
② respuesta rápida(多核)
③ evitan cambios de contexto
spinlock · 三条件
① 临界区极短 ② 多核 ③ 等待可预测。
单核 / 长临界区 = 纯浪费。
mutex · 三条铁律
① init 后是 desbloqueado
② 谁锁谁解(不可跨线程)
③ destroy 前必须解锁
cond_wait 的两个参数
(cond, mutex)——放锁 + 睡是原子的;醒来要重新持锁。
while 不是 if
醒来条件可能不成立(被别人抢先 / spurious wakeup)。
原句:SIEMPRE reevaluarse。
读者 / 写者 · 谁能并发
读×读 ✔ 读×写 ✘ 写×写 ✘。
四条条件的归属:客人等 C1/C3,理发师等 C2/C4(理发师题)。
读/写题:读者等 nesc,写者等 nesc+nlec。
signal 叫谁
PC:生产完叫消费者、消费完叫生产者。
读/写:nlec==0 才叫写者;post_escribir 先叫读者。
理发师 · 四条条件
C1 blibre / C2 socupada
C3 pabierta / C4 pabierta(共用)+ cciclo
数「交接点」就是数条件。
monitor · 三个关键词
Hoare + Hansen、mediados de los 70、siempre en exclusión mutua。
它只是 filosofía,不是语法。
为什么多个 cond
一个等待集混着等不同条件 → signal 叫错人;broadcast 又惊群。
前提:条件可能同时成立就必须拆开。
全章一句话
「短路等待用自旋,长期等待用睡眠,等条件用 cond,封装成类型叫 monitor」🔐

出处:SCTR · Tema 3 «Comunicación y sincronización con memoria compartida» Parte 3 «Spinlocks y Mutex» · p.1–p.52(共 52 页)。本页为逐句对照笔记:.es 为讲义原文,.zh 为中文翻译,绿色为考点、红色为陷阱、紫色为记忆钩子。原文笔误以红底标注,只标注不改写。

学习顺序建议:p.1–p.7(临界区定义与 region 语义)→ p.8–p.12(spinlock 三优点三条件 + 四个 POSIX 函数)→ p.13–p.18(mutex 谁锁谁解 + 四种类型 + 花园实例)→ p.19–p.21(RCC 与隐式忙等)→ p.22–p.28(条件变量:wait 原子性、while 复检、PC 实现)→ p.29–p.31(monitor 三条批评与 Hoare/Hansen 定义)→ p.32–p.35(有界缓冲区与「为什么要多个 cond」)→ p.36–p.40(读者/写者 pre-post 四函数)→ p.41–p.51(睡眠理发师 C1–C4 与三个过程)→ p.52(小结)。

配套:Tema 3 · Parte 1 《espera activa》(忙等 / Peterson / Lamport 面包店)→ Parte 2 《semáforos》 → 本页《spinlock y mutex》。