Tema 2 · Representación de procesos y soporte de la concurrencia
进程表示与并发支持 · 逐页逐句双语讲义

Tema 2: Representación de procesos y soporte de la concurrencia · SCTR
53 页原版 PDF 一页不落 · 西语原句逐字照抄 + 中文一句一译
怎么用这份讲义

一、概念:进程 · 线程 · 任务

p.1–p.9
p.1

Portada · 封面

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

Sistemas Concurrentes y de Tiempo Real

并发与实时系统(课程名称)。

Grado en Ingeniería Telemática

远程通信工程本科专业。

Tema 2: Representación de procesos y soporte de la concurrencia

主题 2:procesos的表示与concurrencia的支持。

本页只是封面:确认课程、专业与主题编号即可。整份讲义(53 页)都围绕「一个proceso里怎么同时跑多条hebra」展开,后面 p.3 起才进入正题。
记法:Tema 2 = «representación de procesos»(进程长什么样)+ «soporte de la concurrencia»(系统怎么支撑并发)——一半讲模型,一半讲实现。
p.2

Índice de contenidos · 目录

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

Índice de contenidos

内容目录。

• Conceptos

• 基本概念。

• Modelos de creación

• 创建模型。

• Jerarquía de procesos

• Jerarquía de procesos。

• Inicialización

• 初始化。

• Terminación

• 终止。

• Creación y representación

• 创建与表示。

• El modelo de proceso/hebras en Unix/Linux

• Unix/Linux 中的proceso/hebras模型。

• POSIX

• POSIX 标准。

• Ciclo de vida de una hebra

• 一条hebra的生命周期。

考点:目录本身就是一条答题主线——«conceptos → modelos de creación → jerarquía → inicialización → terminación → representación → Unix/Linux → POSIX → ciclo de vida»。问「Tema 2 讲了什么」按这 9 个词答即可。
注意目录把 «inicialización» 与 «terminación» 分开列:p.18 之后讲进程怎么起、p.30 前后讲怎么收,中间插 Unix/Linux 的表示法,别把顺序记反。
p.3

Conceptos · 基本概念

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

P || Q || R significa que la ejecución de P, Q y R puede solaparse en el tiempo.

P || Q || R 表示 P、Q、R 三者的执行在时间上可以相互交叠。

¿Cómo se representa esto en un sistema real?

在真实系统中,这一点该如何表示?

Podemos hablar de procesos, hebras, tareas, … pero no son lo mismo

我们可以谈procesos、hebras、tareas……但它们并不是同一回事。

En la asignatura nos vamos a centrar en concurrencia con hebras

本课程将聚焦于用hebras实现的concurrencia。

考点:能解释 P || Q || R——不是「同时」而是「concurrencia = 执行区间可重叠(puede solaparse en el tiempo)」。答题关键词:solaparse en el tiempo。
易错:P || Q || R 只保证「可能重叠」,不等于并行(paralelismo)。单核上交错执行同样满足;答题时区分 concurrencia(并发,逻辑)与 paralelismo(并行,物理)。
口诀:proceso = 有自己房子的住户;hebra = 合租的室友;tarea = 房东口中的「那件事」。三个词都能「同时干活」,但共享程度不同。
p.4

Conceptos · 进程的定义

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

Proceso: instancia en ejecución de un programa. Contiene su propio espacio de direcciones, recursos asignados (ficheros, memoria) y al menos un flujo de control

Proceso:一个程序正在执行的实例。它拥有自己的espacio de direcciones、已分配的资源(文件、内存),以及至少一条flujo de control。

Tiene un contexto de ejecución completo

它具有完整的contexto de ejecución。

Registros, pila, heap, datos del programa

Registros、pila、heap、程序数据。

Unidad básica de ejecución y aislamiento para el sistema operativo

它是操作系统进行执行与aislamiento的基本单位。

考点:背下三要素——espacio de direcciones propio + recursos asignados + al menos un flujo de control;再补一句「es la unidad básica de ejecución y aislamiento」。这句是问「进程是什么」的标准答案开头。
记忆钩子:进程的私有财产 = Registros、Pila、Heap、Datos(RPHD),再加地址空间——「RPHD 全私有」。
对比 p.6:hebra只保留 RPHD 里的「R + P」(寄存器和栈),heap 与 datos 变共享——这一页先立「私有」的基准。
p.5

Ejemplos procesos · 进程示例(C 与 Python)

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

Ejemplos procesos

进程示例。

printf("Proceso: PID = %d\n", getpid());

打印 «Proceso: PID = %d»,其中 getpid() 返回当前进程的 PID。

fork();

fork():复制出一个proceso hijo,父子各自继续执行后面的代码。

printf("Hola desde un proceso\n");

打印 «Hola desde un proceso»(来自一个进程的问候)——注意 fork 之后这一行会被父、子两个进程各执行一次。

from multiprocessing import Process

Python 侧导入 multiprocessing.Process,用进程而非线程来做并行。

p = Process(target=trabajo)

创建一个子进程对象 p,入口函数是 trabajo。

p.start()

start() 真正启动子进程(此时才发生创建)。

p.join()

join() 让父进程等待子进程结束——对应 p.12 所说的「父进程可以等待子进程终止」。

陷阱:fork() 之后父子进程共享的是「代码 + 写时复制的内存镜像」,不是同一个地址空间实体;而且 printf 那行在 C 例子里会出现两次。别答成「fork 创建线程」。
考点:给一段 fork() 代码问「输出几行」——答案 = 进程数。本例 1 次 fork → 2 个进程 → 第二个 printf 输出 2 次。
p.6

Conceptos · 线程(hebra)的定义

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

Hebra (hilo, thread): unidad de ejecución más ligera que un proceso. Se ejecuta asociada a un proceso

Hebra(hilo、thread):比proceso更轻量的执行单位,它与某个进程绑定运行。

Las hebras de un proceso comparten su espacio de direcciones y recursos (heap, ficheros, etc.)

同一进程内的各条hebras共享该进程的espacio de direcciones与资源(heap、文件等)。

Tienen su propio contador de programa, pila y registros

但它们各自拥有contador de programa、pila和registros。

Permiten concurrencia dentro de un mismo proceso (multithreading)

它们使同一个进程内部也能有concurrencia(即multithreading)。

考点:必背对照——共享:espacio de direcciones、heap、ficheros;私有:contador de programa、pila、registros。考题常问「¿Qué comparten las hebras de un proceso?」。
口诀:「共享房子,私人家当」——房子 = 地址空间/heap/文件;家当 = PC/栈/寄存器。有了私有 PC,每条线程才能各跑各的指令流。
「más ligera」的直接原因是:创建线程不必复制地址空间,所以上下文切换与创建开销都比进程小——这正是 p.6 与 p.4 的差别所在。
p.7

Ejemplos hebras · 线程示例(C pthread 与 Python Thread)

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

Ejemplos hebras

线程示例。

#include <pthread.h>

引入 POSIX 线程库头文件 pthread.h——p.45 起会正式讲 POSIX。

void* trabajo(void* arg) { printf("Hola desde una hebra\n"); return NULL; }

线程入口函数 trabajo:签名必须是 void* f(void*),内部只打印一句 «Hola desde una hebra»,然后返回 NULL。

pthread_t t;

声明一个标识符 pthread_t t,用来代表新建的线程。

pthread_create(&t, NULL, trabajo, NULL);

pthread_create 创建一个hebra:参数依次是线程句柄地址、属性(NULL = 默认)、入口函数、传给入口函数的参数。

pthread_join(t, NULL);

pthread_join 等待该线程结束(对应 Python 的 join())。

from threading import Thread

Python 侧改用 threading.Thread(线程),与 p.5 的 multiprocessing.Process 形成对照。

t.start() / t.join()

start() 启动线程,join() 等待其结束——与进程版写法结构完全一样。

考点:会写最小 pthread 三件套——create → (工作) → join;并说出 pthread_create 四个参数的含义。常考比较题:这段代码把 pthread_create 换成 fork 会有什么不同?
易错:pthread_create 的第三个参数是函数名(函数指针),不能写成 trabajo();第四个参数才是线程函数的实参。写成 trabajo() 是语法错误,属常见扣分点。
p.8

Conceptos · 任务(tarea)

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

Tarea: término genérico y dependiente del contexto. Puede referirse, entre otros a:

Tarea:一个泛称,含义取决于上下文。它可以指(但不限于):

Trabajo que debe realizarse

需要完成的工作本身。

En algunos lenguajes (p.ej. Ada) se usan como sinónimo de hebra o proceso ligero

在某些语言里(例如 Ada),它被当作hebra或proceso ligero的同义词。

Puede ser también una abstracción de operación asíncrona

它也可以是operación asíncrona的一种抽象。

En general, los algoritmos y soluciones que se verán a lo largo de la asignatura pueden aplicarse (con sus particularidades) tanto a procesos como a hebras

总体而言,本课程要讲的算法与解法(在各自的具体细节之下)对procesos和hebras都适用。

考点:能说出 tarea 的三种含义——(1) 要做的工作、(2) Ada 里等价于线程/轻量进程、(3) 异步操作的抽象;并强调它是 «término genérico»,不是精确的技术术语。
记忆钩子:tarea = 「活」(口语的「那活儿」)。至于谁来干这活——进程还是线程——要看上下文,所以教材说它 «dependiente del contexto»。
承接关系:p.3 说三者「no son lo mismo」,本页把最模糊的那个(tarea)定义清楚;下一批页 p.10 起转向「怎么创建」。
p.9

Ejemplos tareas · 任务示例(Ada 与 Python asyncio)

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

Ejemplos tareas

任务示例。

task type Trabajador;

Ada 里声明一个task type(任务类型)Trabajador——Ada 的 task 即并发执行单位。

task body Trabajador is begin Put_Line("Ejecutando tarea"); end Trabajador;

任务体:执行时只输出 «Ejecutando tarea»(正在执行任务),随后结束。

import asyncio

Python 侧引入 asyncio——把「任务」实现为corrutina的异步操作。

async def descargar(): await asyncio.sleep(2)

用 async def 定义协程 descargar,其中 await 挂起 2 秒,模拟一次下载。

tarea = asyncio.create_task(descargar())

create_task 把一个协程包装成可调度的tarea——这就是「异步操作抽象」的实例。

print("La tarea se ejecuta de forma asíncrona")

打印 «La tarea se ejecuta de forma asíncrona»(任务以异步方式执行)。

await tarea

await tarea:等待该任务完成,等价于线程里的 join。

考点:区分三种「任务」实体——Ada 的 task 是真并发单位;Python asyncio task 是事件循环上的协程调度单位(单线程内切换)。问「任务一定是新线程吗?」答案:不一定。
易错:asyncio.create_task 不会新建hebra,它只是把协程注册到事件循环;await asyncio.sleep(2) 期间并不阻塞线程,只是让出控制权。
记忆钩子:Ada 的 task = 「会自己跑的代码块」;asyncio 的 task = 「排队的差事」;两者都叫 tarea,但一个靠内核调度,一个靠事件循环调度。

二、创建模型 · 进程层级 · 初始化与终止

p.10–p.17
p.10

Modelos de creación · 创建模型

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

Pueden utilizarse diferentes estrategias en relación a cuándo se pueden crear los procesos/hebras:

就「何时可以创建进程/线程」这一点,可以采用不同的策略:

Creación inicial: los procesos/hebras se crean al inicio de nuestro programa

Creación inicial:所有进程/线程在我们程序一开始时就被创建。

Creación dinámica: los procesos/hebras pueden crearse en cualquier momento para atender nuevas peticiones o cargas de trabajo

Creación dinámica:进程/线程可以在任意时刻创建,以处理新的请求或工作负载。

El número máximo de procesos/hebras está limitado por los recursos de la máquina (memoria, núcleos, SO)

进程/线程的最大数量受机器资源限制(内存、núcleos、操作系统)。

Qué estrategia a utilizar depende del tipo de aplicación

采用哪种策略取决于应用的类型。

Por ejemplo, en sistemas de tiempo real, se suelen crear todas las tareas al comienzo para poder analizar su comportamiento temporal más adecuadamente

例如在sistemas de tiempo real中,通常在一开始就创建全部tareas,以便更恰当地分析它们的时间行为。

考点:二分法 + 理由。¿Cuándo crear? → creación inicial vs creación dinámica;为什么实时系统选初始创建?关键词:analizar el comportamiento temporal(可静态分析时间行为)。
口诀:实时系统「一次点齐」(初始创建,才能算清最坏响应时间);服务器「来一个开一个」(动态创建,应对请求洪峰)。
上限三要素(memoria / núcleos / SO)在 p.4 的「recursos asignados」里有伏笔:每个proceso要占地址空间,每条hebra要占栈,都吃内存。
p.11

Creación inicial vs dinámica · 两种创建方式对照

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

Creación inicial vs dinámica

初始创建 vs 动态创建。

void* tarea(void* arg) { // trabajo de la hebra return NULL; }

两种模式共用的线程入口函数 tarea(左栏):函数体是注释 «trabajo de la hebra»(线程要做的工作)。

pthread_t h1, h2, h3;

左栏(初始创建):一次性声明 h1, h2, h3 三个线程句柄。

pthread_create(&h1, NULL, tarea, NULL); pthread_create(&h2, NULL, tarea, NULL); pthread_create(&h3, NULL, tarea, NULL);

在 main 里连续创建三条hebras——数量在编码时就固定下来,这就是creación inicial。

// El programa continúa...

注释 «El programa continúa...»:程序继续往下走(不再创建新线程)。

while (1) { peticion = esperar_peticion(); pthread_t h; pthread_create(&h, NULL, atender, peticion); }

右栏(动态创建):死循环里每来一个请求就 pthread_create 一条hebra去处理——数量取决于运行时的请求数,这就是creación dinámica。

考点:看代码判模式——create 写在 main 直线上、次数固定 → 初始创建;create 写在 while / 事件回调里、次数不定 → 动态创建。答题要同时点出「cuándo」与「cuántos」。
陷阱:右栏 pthread_t h 是循环内的局部变量,循环结束即销毁,却没有 join——真实工程会遇到「线程还在跑、句柄已失效」,属示例简化的欠妥之处;考试若问「这段有什么问题」可答:缺少 join/detach。
串起 p.10:左栏对应「所有 tareas 开始时创建」(便于时间分析),右栏对应「按 peticiones 随时创建」(服务器模型)。
p.12

Jerarquía de procesos · 进程层级

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

Jerarquía de procesos

进程层级。

Posibilidad de anidar unos procesos dentro de otros.

即可以把一些进程嵌套在另一些进程之中。

Existe una relación padre/hijo entre el proceso desde el que se crea a otro proceso, y el nuevo proceso creado (llamada fork)

创建者进程与被创建的新进程之间存在relación padre/hijo(创建动作即系统调用 fork)。

El proceso hijo hereda algunos atributos del padre (p.ej. descriptores de fichero, entorno)

子进程会继承父进程的部分属性(例如descriptores de fichero、entorno)。

Habitualmente no existen este tipo de jerarquía entre hebras

通常各hebras之间不存在这种层级关系。

Aunque una hebra puede crear a otras, pero es una relación de “origen”

尽管一条线程可以创建别的线程,但那只是「来源」意义上的关系(而非父子层级)。

Esta jerarquía es mantenida por el sistema operativo

该层级由操作系统维护。

P.ej. en Linux el proceso padre conoce el PID de sus hijos y viceversa

例如在 Linux 中,父进程知道其子进程的 PID,反之亦然。

La finalización de los hijos puede ser esperada por el padre

子进程的terminación可以由父进程等待(wait)。

Cuando iniciamos un programa, el proceso asociado es el padre de todos los procesos creados por él

当我们启动一个程序时,与之对应的进程就是它创建的所有进程之父。

Sí que existe una relación entre un proceso y sus hebras

但进程与它的hebras之间确实存在关系。

Las hebras no pueden existir sin el proceso

没有该进程,这些线程就不能存在。

考点:三点必答——(1) 进程有 jerarquía padre/hijo(fork 产生、OS 维护、父可 wait);(2) 线程没有这种层级,只有「谁创建谁」的来源关系;(3) 线程依附于进程存在。
勘误提醒:原文 «Aunque una hebra puede crear a otras, pero es una relación de “origen”» 里的 pero 属口语冗余(«aunque… pero…» 在规范西语中不并用),语义是「虽然线程可以派生线程,但这只是来源关系」。照抄原文,理解时去掉 pero 即可。
记忆钩子:进程像族谱(有爸爸有儿子),线程像同事(只有「谁招进来的」)。族谱归 OS 管,同事关系归进程内部管。
p.13

Ejemplo jerarquía · 进程层级示例

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

Ejemplo jerarquía

进程层级示例。

#include <sys/wait.h>

引入 sys/wait.h,才能使用 wait 系列函数等待子进程。

pid_t hijo = fork();

fork() 的返回值存在 hijo 里:父进程中它是子进程的 PID,子进程中它是 0。

if (hijo == 0) { printf("Hijo: PID=%d, padre=%d\n", getpid(), getppid()); }

分支 hijo == 0 是子进程:打印自己的 getpid() 与父进程 getppid()。

printf("Padre: PID=%d, hijo=%d\n", getpid(), hijo);

父进程分支:打印自己的 PID 以及刚创建的子进程 PID。

wait(NULL);

父进程 wait(NULL) 阻塞,直到某个子进程终止——正是 p.12 说的「父可等待子进程结束」。

Padre (PID 100) | fork() ↓ Hijo (PID 101)

页下图示:父进程(PID 100)经 fork() 派生出子进程(PID 101),即一棵两层的进程树。

考点:fork() 返回值的三种情况必须背——>0(父进程,值是子 PID)、==0(子进程)、<0(创建失败)。本题只用到前两种;问「输出几行」时把图示的 2 个进程数清。
易错:getpid() 取自己,getppid() 取父进程,两个函数只差一个 p,考试常故意写反。另注意 hijo 变量在父子两个进程里存在两份副本,值不同。
记忆钩子:「父拿号,子拿 0」——父进程收到子进程的号(PID),子进程收到 0,于是 if (hijo == 0) 一定进子分支。
p.14

Inicialización · 初始化

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

Para darle valores iniciales a un proceso/hebra se suelen utilizar dos métodos:

给进程/线程赋初值通常有两种方法:

Paso de parámetros: como en los procedimientos o métodos

Paso de parámetros:像普通过程或方法那样传参。

Paso de mensajes: el proceso padre o hebra, cuando crea un proceso/hebra le envía un mensaje para inicializar sus variables

Paso de mensajes:父进程或线程在创建新进程/线程时,发一条消息去初始化它的变量。

En ambos casos hay que tener cuidado con la reutilización de los parámetros

两种方式都要小心参数的复用问题。

Como distintos valores iniciales pueden dar lugar a distintos comportamientos, es natural introducir el concepto de tipo de proceso/hebra.

由于不同的初值会导致不同的行为,自然会引入「tipo de proceso/hebra」这个概念。

Podemos definir un patrón de comportamiento común y luego instanciarlo varias veces para obtener distintos procesos/hebras que, aunque comparten el código, pueden comportarse de forma distinta dependiendo de sus valores iniciales.

我们可以定义一个共同的行为patrón,然后多次实例化,得到不同的进程/线程:它们虽然共享同一段代码,却会因初值不同而表现不同。

考点:两种初始化方式的名字与区别——paso de parámetros(创建时直接传值)vs paso de mensajes(创建后发消息设初值);再答「为什么需要 tipo de proceso/hebra」:因为初值不同 → 行为不同,同一段代码要能多实例化。
陷阱:「reutilización de los parámetros」指不要用会变的共享变量(或已失效的指针)当参数——p.15 的 &id 例子就会踩这个坑,创建线程后主函数若改动 id,线程读到的值可能已变。
记忆钩子:参数是「出生证明」,消息是「出生后的第一封信」。前者在 create 那一刻写定,后者发生在创建之后。
p.15

Ejemplos inicialización · 初始化示例(参数传递 / 管道消息)

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

Ejemplos inicialización

初始化示例。

Paso de parámetros

参数传递(左栏标题)。

int id = *(int*)arg;

线程入口里把 void* 强转成 int* 再解引用,取出传进来的编号。

pthread_create(&hilo, NULL, trabajador, &id);

创建线程时把 &id 作为参数传给 trabajador——初值通过paso de parámetros完成。

int fd[2]; pipe(fd);

右栏(消息传递):pipe(fd) 创建一条单向管道,fd[0] 读、fd[1] 写。

if (fork() == 0) { // Hijo char msg[10]; read(fd[0], msg, 10); printf("Valor: %s\n", msg); }

子进程从 fd[0] 读最多 10 字节到 msg,再打印收到的值——这就是用消息给新进程赋初值。

else { // Padre write(fd[1], "42", 3); wait(NULL); }

父进程往 fd[1] 写入字符串 «42»,然后 wait(NULL) 等子进程结束。

Padre ── write("42") ──→ pipe ── read() ──→ Hijo

页下流程图:父进程 write("42") → 管道 → 子进程 read(),即paso de mensajes的完整路径。

考点:两条初始化路线的代码识别——pthread_create 的第 4 参数 = paso de parámetros;pipe + write/read = paso de mensajes。问「管道里传的是什么」答:字节流(此处是字符串 «42»,含结尾 \0 共 3 字节)。
易错:write(fd[1], "42", 3) 的 3 把结尾的 \0 也算进去,所以子进程 printf("%s") 才能正常结束;写 2 就少了终结符。另:&id 若在 create 之后被修改,线程可能读到新值(p.14 说的 reutilización 风险)。
记忆钩子:管道 = 进程间的传纸条,fd[0] 是收信箱(读),fd[1] 是投递口(写)——「0 读 1 写」。
p.16

Terminación · 终止

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

Un proceso/hebra puede acabar su ejecución por distintas causas:

一个进程/线程结束执行可能有多种原因:

cuando se acaba su código (terminación con éxito)

代码执行完毕(terminación con éxito);

cuando tiene un error durante su ejecución (terminación con fallo)

执行过程中出错(terminación con fallo);

por la ejecución de una instrucción de autodestrucción

执行了一条自我销毁指令(如 exit / pthread_exit);

cuando otro proceso/hebra aborta su ejecución

被另一个进程/线程中止(如 pthread_cancel、kill)。

En muchas ocasiones querremos obtener algún resultado proporcionado por el proceso/hebra que ha terminado

很多时候我们想拿到已结束进程/线程给出的某个结果。

Habrá que esperar a la finalización

那就必须等待它finalización(join / wait)。

Un proceso/hebra puede no terminar

进程/线程也可能「不结束」:

siendo éste su comportamiento esperado

这本身就是它期望的行为(如服务器主循环);

como consecuencia de un error en su diseño

或者是设计错误导致的结果(死锁、死循环)。

考点:四种终止原因按题答——código acabado / error / autodestrucción / abortado por otro。「不终止」也要分两种:esperado(设计如此)vs error de diseño。这是概念题高频点。
记忆钩子:「善终、暴毙、自尽、他杀」四类,再加「不死」两型(该活的与改不掉的 bug)。
串起 p.17:要拿结果就得「esperar a la finalización」——C 用 wait 取状态码,线程用 pthread_join 取返回值。
p.17

Ejemplo terminación · 终止示例(退出码与等待)

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

Ejemplo terminación

终止示例。

Terminación normal / con error

正常终止 / 出错终止(左栏标题)。

int resultado = calcular(); if (resultado >= 0) return 0; // éxito else return 1; // fallo

算得 resultado:非负就 return 0(成功),否则 return 1(失败)——返回值即código de salida。

./programa

在 Bash 里运行程序。

resultado=$?

用 $? 取出上一条命令的退出码。

echo "El proceso terminó con: $resultado"

打印 «El proceso terminó con: …»(进程以此状态结束)。

Esperar terminación

等待终止(右栏标题)。

if (hijo == 0) { printf("Trabajando...\n"); return 42; }

子进程打印 «Trabajando...» 后以状态码 42 结束。

int estado; wait(&estado);

父进程用 wait(&estado) 等待,并把子进程的estado写入 estado。

printf("Hijo terminado: resultado=%d\n", WEXITSTATUS(estado));

用 WEXITSTATUS 从状态字里抽出真正的退出码,打印 «Hijo terminado: resultado=42»。

考点:wait 给的是「状态字」,不是退出码;必须用 WEXITSTATUS(estado) 才能取出 42。问「为什么不能直接打印 estado」是经典送分题。
陷阱:退出码只有低 8 位可用(0–255),写 return 300 会被截断成 44。另:Bash 的 $? 与 C 的 return 是同一套退出码,别混成两种机制。
记忆钩子:「W 一下才看得见」——状态字外面包着一层壳,WEXITSTATUS 是剥壳工具;还有 WIFEXITED 判「是否正常退出」。
p.18

Creación y representación · 创建与表示

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

La creación de un proceso/hebra suele ser explícita mediante la utilización de alguna función o método

进程/线程的创建通常是显式的:要调用某个函数或方法。

Que hayamos creado el proceso/hebra no quiere decir que comience a ejecutarse de inmediato

但「已创建」并不意味着它立刻开始执行。

Esto depende del “planificador” del Sistema Operativo (o máquina virtual de nuestro lenguaje)

这取决于操作系统的planificador(或所用语言的虚拟机)。

La representación de los procesos/hebras puede ser

进程/线程的表示方式可以是:

Explícita: el lenguaje proporciona un constructor específico para definir a los procesos

Explícita:语言提供专门的构造(constructor)来定义进程。

Implícita: se usan otras construcciones del lenguaje como funciones o métodos para delimitar el código de la hebra o proceso.

Implícita:借用语言中其他构造(函数或方法)来界定线程/进程的代码。

Más habitual hoy día

如今更常见的是后者(隐式表示)。

考点:两个两分法要能背——创建几乎总是显式(función/método);表示分 explícita(专门的 constructor,如 Java extends Thread)与 implícita(用函数/方法界定代码,如今更常见)。另问「创建完是否立即运行」→ 取决于 planificador。
易错:把「创建(creación)」与「表示(representación)」混为一谈。创建回答「谁去调用什么」,表示回答「语言怎么描述一个进程/线程」。
记忆钩子:显式 = 有专门的「户口本」(constructor);隐式 = 拿普通纸张(函数/方法)凑合登记。今天流行隐式,因为 lambda 更省事(见 p.19)。
p.19 就是这两种表示的 Java 对照:左栏 class Trabajador extends Thread 是显式,右栏 pool.submit(() -> …) 是隐式。
p.19

Ejemplo creación · Java 显式与隐式表示

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

Ejemplo creación

创建示例。

Java - creación explícita

Java —— creación explícita。

class Trabajador extends Thread { @Override public void run() { System.out.println("Ejecutando"); } }

定义类 Trabajador 继承 Thread,重写 run() 作为线程体,输出 «Ejecutando»(执行中)。语言层面有专门的 constructor(extends Thread),故属representación explícita。

Trabajador t = new Trabajador(); t.start();

实例化并通过 t.start() 启动线程;注意 start 只是「交给调度器」,不等它跑(见 p.18)。

Java - representación implícita

Java —— representación implícita。

ExecutorService pool = Executors.newFixedThreadPool(2);

建一个固定 2 条线程的pool。ExecutorService 才是线程设施,任务是普通 lambda,故属representación implícita。

pool.submit(() -> { System.out.println("Ejecutando tarea"); });

提交一个 lambda 作为任务,打印 «Ejecutando tarea»(正在执行任务)——没有专门的「进程/线程类」,代码块本身就是线程体。

pool.shutdown();

shutdown() 停止接收新任务,等在跑的任务结束后关闭池。

考点:给 Java 代码判断表示方式——看见 extends Thread / implements Runnable 是显式;看见 ExecutorService + submit(lambda) 是隐式。理由一句话:显式有专门的 constructor,隐式用函数/方法(lambda)界定代码。
易错:t.start() 不是 t.run()。直接调 run() 只在当前线程里顺序执行,不会新建线程——这是 Java 并发题最常见的陷阱选项。
记忆钩子:显式 = 先造一个「工人对象」再 start;隐式 = 往「劳务市场」丢一张任务单(submit)。
p.20

El modelo de proceso/hebras en Unix/Linux · PCB

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

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

En sistemas Unix/Linux, un proceso es una instancia en ejecución de un programa.

在 Unix/Linux 系统中,proceso是一个程序正在执行的实例。

Información asociada al proceso en el PCB (Process Control Block) gestionado por el SO

与进程相关的信息存放在 PCB(Process Control Block)中,由操作系统管理。

Process ID, PPID, UID / GID, process group ID

Process ID、PPID(父进程号)、UID / GID(用户/组标识)、进程组 ID。

Contador de programa, registros de CPU y estado del planificador

Contador de programa、CPU registros以及planificador状态。

Instrucciones del programa

程序的指令(代码段)。

Datos estáticos

静态数据。

Pila (stack)

Pila(stack)。

Heap

Heap(堆)。

Variables de entorno y directorio de trabajo

Variables de entorno与directorio de trabajo。

Descriptores de fichero abiertos

已打开的descriptores de fichero。

Acciones de señales

señales的处理动作。

Librerías compartidas cargadas

已加载的librerías compartidas。

Comunicación entre procesos (colas de mensajes, semáforos, memoria compartida)

Comunicación entre procesos(消息队列、semáforos、memoria compartida)。

考点:问「PCB 里有什么」按四组答最稳——(1) 标识(PID/PPID/UID/GID/process group);(2) 执行状态(PC、registros、estado del planificador);(3) 存储(instrucciones、datos estáticos、pila、heap、librerías);(4) 环境与资源(entorno、cwd、fd、señales、IPC)。
记忆钩子:PCB = 进程的「身份证 + 银行卡 + 保险箱钥匙」:身份(PID 系)、账户状态(PC/寄存器/调度态)、资产清单(内存段、fd、IPC)。
与 p.6 呼应:hebra只私有 PC、pila、registros 三项,其余 PCB 内容都是「进程级」共享——所以 PCB 描述的是进程,不是线程。
p.21

El modelo de proceso/hebras en Unix/Linux · top 实测

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

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

• top

• top:Unix/Linux 下实时查看进程的命令行工具。

top - 09:52:47 up 46 min, 1 user, load average: 0,03, 0,02, 0,00

截图首行:当前时间 09:52:47、已开机 46 分钟、1 个用户、load average 分别为 1/5/15 分钟均值。

Tareas: 135 total, 1 running, 134 sleeping, 0 stopped, 0 zombie

任务统计:共 135 个,1 个running、134 个 sleeping(睡眠)、0 个 stopped、0 个zombie。

MiB Mem: 7941,3 total, 6945,8 free, 805,6 used, 428,3 buff/cache

内存(MiB):总量 7941.3、空闲 6945.8、已用 805.6、缓冲/缓存 428.3。

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND

列头:PID、用户、优先级 PR、nice 值 NI、虚拟内存 VIRT、常驻内存 RES、共享内存 SHR、状态 S、CPU%、内存%、累计 CPU 时间 TIME+、命令名 COMMAND。

1 root 20 0 167864 12340 9176 S 0,0 0,2 0:00.68 systemd

示例行:PID 1 的 systemd(PID 1 是所有用户进程的祖先,对应 p.12 的「父进程」概念),状态 S = sleeping。

僵尸进程在 top 里显示为 Z,已被回收不到但 PCB 尚未被父进程 wait 走;截图里 «0 zombie» 说明当前没有。这一页只用来看「PCB 里的字段在工具中长什么样」,记 PID / PR / NI / VIRT / RES / S / %CPU / COMMAND 即可。
考点:能指着 top 说出「哪个字段对应 PCB 的哪一项」——PID → Process ID;S → estado del planificador;VIRT/RES → memoria(heap、datos、pila)。另问「load average 三个数是什么」→ 1、5、15 分钟的平均负载。
记忆钩子:top 就是 PCB 的「橱窗」——里面摆的都是 p.20 那张清单上的东西,只是换成了列名。
p.22

Ejemplo procesos Linux · ps 与 /proc

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

Ejemplo procesos Linux

Linux 进程示例。

int x = 42; // datos

局部变量 x,注释 «datos»(数据,位于栈上)。

char *p = "Hola"; // datos

指向字符串字面量 «Hola» 的指针,注释 «datos»(属静态数据)。

printf("PID: %d\n", getpid()); printf("PPID: %d\n", getppid());

打印自己的 PID 与父进程 PPID——证明 PCB 里确实存着这两个标识。

printf("PWD: %s\n", getenv("PWD"));

用 getenv("PWD") 取出环境变量 PWD,即当前directorio de trabajo。

sleep(300);// mantener el proceso vivo

睡眠 300 秒,注释 «mantener el proceso vivo»(让进程活着,便于另开终端观察)。

$ ps -f

用 ps -f 查看完整格式的进程列表。

UID PID PPID CMD / juan 1234 1000 ./programa

输出:用户 juan、PID 1234、PPID 1000,命令 ./programa——一眼看出父子关系。

$ cat /proc/1234/environ

读取 /proc/1234/environ:进程的环境变量数组(PCB 内容的文件化视图)。

$ ls -l /proc/1234/fd

列出该进程的 fd 目录:所有打开的descriptores de fichero。

/proc/1234/ ├── cwd → directorio de trabajo ├── fd/ → descriptores de fichero ├── maps → memoria y librerías cargadas └── status → PID, PPID, UID, estado...

目录结构:cwd → 工作目录;fd/ → 文件描述符;maps → 内存映射与已加载库;status → PID、PPID、UID、状态等。

考点:/proc/<PID>/ 四个子项要能对上 PCB 字段——cwd=directorio de trabajo、fd/=descriptores de fichero、maps=librerías/memoria、status=PID/PPID/UID/estado。这是「PCB 在 Linux 中的落地形式」标准答法。
易错:/proc 不是磁盘上的真目录,是内核导出的虚拟文件系统(procfs);读它等于向内核查询 PCB,文件大小通常显示为 0。
记忆钩子:ps 是「点名册」,/proc 是「档案柜」——点名册只给摘要,档案柜能逐项翻。
p.23

El modelo de proceso/hebras en Unix/Linux · 线程与进程的关系

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

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

Las hebras se utilizan y definen dentro de los procesos

Las hebras在procesos内部被使用和定义。

Pueden ser planificadas por el SO

它们可以由操作系统planificadas(调度单位是线程级实体)。

Se ejecutan como entidades independientes duplicando los recursos mínimos

它们作为独立实体执行,只复制最少的资源(即「轻量」的由来)。

考点:三句话概括线程在 Unix/Linux 中的地位——定义/使用在进程内、可被 OS 调度、只复制最小资源。问「线程与进程谁被调度」答:Linux 里两者都是可调度实体(task),但线程共享进程的地址空间。
记忆钩子:「房间里的工人」——房间 = 进程,工人 = 线程;工人可以各自被叫去干活(planificadas),但只带自己的工具(recursos mínimos),不另盖房子。
易错:说「线程不是调度单位」是错的(现代 OS 以线程为调度单位);说「线程复制整个地址空间」也是错的(只复制最小资源)。
p.24

El modelo de proceso/hebras en Unix/Linux · 每条线程私有什么

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

Cada hebra mantiene sus propios

每条hebra各自维护以下内容:

Identificador de hebra

线程标识符(TID)。

Registros (incluido contador del programa)

Registros(其中包含contador del programa)。

Puntero a la pila

指向pila的指针。

Propiedades y estado de planificación (prioridad y política)

调度属性与状态(prioridad与política)。

Señales pendientes y bloqueadas

挂起与被屏蔽的señales。

Datos de la hebra (argumentos o variables locales)

线程自身的数据(参数或局部变量)。

考点:这一页就是 p.6 的「私有清单」的 Unix/Linux 细化版,考「线程私有资源」要写全 6 项:TID、registros(含 PC)、puntero a pila、propiedades/estado de planificación、señales pendientes/bloqueadas、datos locales。考试若只写「栈和寄存器」会丢分。
记忆钩子:「一号两器三态」——1 个 TID、寄存器 + 栈指针、调度/信号/局部数据三类状态。
与 p.20 的 PCB 对照:PCB 里这些字段原本属于「进程」,改用线程后,这 6 项被拆出来放进线程控制块(TCB),其余仍留进程级——这就是 p.26 图示的右半部分。
p.25

El modelo de proceso/hebras en Unix/Linux · top -H 观察线程

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

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

• top -H

• top -H:-H 表示按线程显示,而不是按进程显示。

Hilos: 251 total, 5 running, 246 sleeping, 0 stopped, 0 zombie

截图第二行变成 «Hilos»(线程):共 251 条、5 条running、246 条 sleeping、0 stopped、0 zombie。

1419 usuario 20 0 92588 896 804 S 99,9 0,0 2:42.11 a.out

截图中的 a.out 进程 PID 1419 下,出现多条同 PID 的行,各自 %CPU 与 TIME+ 不同——同一条proceso内的不同线程。

ps -T -p 1419 -o pid,tid,pcpu,comm

右下角用 ps -T 指定 tid 列:输出 PID 1419 + TID 1419/1420/1421/1422,恰好 1 个主线程 + 3 条新线程。

PID TID %CPU COMMAND

列头:进程号 PID、线程号 TID、CPU 占用、命令名——PID 相同而 TID 不同,正是「一线程一 TID」的直接证据。

考点:会解释 top -H 与 ps -T 的意义——按线程维度看同一进程内的执行流;判据是「同一 PID 多行、TID 各不相同」。这页与 p.29 的 ps -T -p 1614 是同一实验的两半。
记忆钩子:-H = Hilos,-T = Threads,两个开关都在说「拆到线程看」。
看到 4 条 TID 说明程序里有 1 条主线程 + 3 条 pthread_create 出来的线程;sleep(300) 让它们同时处于 S(sleeping)态,便于观察。
p.26

El modelo de proceso/hebras en Unix/Linux · 单线程 vs 多线程地址空间

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

Espacio de dirección del usuario

Espacio de dirección del usuario(左:单线程进程;右:多线程进程)。

pila · codigo · datos · heap

左图(单线程):pila → codigo(代码)→ datos(数据)→ heap,整个地址空间只服务一条执行流。

Pila hebra1 · Pila hebra2

右图(多线程):地址空间上方多出 Pila hebra1、Pila hebra2——每条hebra有自己的pila。

codigo · datos · heap

右图中 codigo、datos、heap 仍然只有一份,被所有线程共享。

Contador de programa · Puntero a pila

右侧小方块(线程私有):Contador de programa与Puntero a pila,每条线程各一份(图中有两条箭头分别指向两个栈)。

Id Proceso · Id Grupo · Id Usuario

进程级标识:Id Proceso、Id Grupo、Id Usuario——所有线程共用同一套。

Ficheros, Sockets

打开的文件与套接字位于进程级,被所有线程共享。

考点:这张图是必考图。能画出并标注——共享:codigo、datos、heap、ficheros/sockets、Id Proceso/Grupo/Usuario;私有:每条线程的 pila、Contador de programa、Puntero a pila。问「为什么线程切换比进程快」直接指这张图:地址空间不用换。
记忆钩子:「一个客厅,多个工位」——客厅(codigo/datos/heap/文件)大家共用,工位(pila + PC + 栈指针)各人一套。
易错:右图里栈是往上叠的(hebra1、hebra2 各占一段),别误以为线程共享同一个栈;栈指针不同就是最直接的反证。
p.27

El modelo de proceso/hebras en Unix/Linux · 共享内存与线程私有区

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

Memoria Compartida

Memoria Compartida:图中央的大椭圆,是进程内所有线程共同读写的区域。

Hebra

周围 5 个圆角方块各代表一条Hebra,都用箭头连向中央的共享内存。

privado

每条线程外侧的小黄方块标着 privado(私有):即各自的寄存器/栈等不被别人看到的区域。

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

纯图页:核心信息只有两个词——Memoria Compartida(共享区,线程间通信与数据交换的通道)与 privado(每线程私有区)。与 p.26 的「客厅/工位」是同一件事的另一种画法。
考点:问「线程之间怎么交换数据」→ 通过 Memoria Compartida(进程的地址空间);问「线程什么不能共享」→ 标着 privado 的那部分(寄存器、栈)。
易错:共享内存是线程间默认共享,但进程之间要显式用 IPC(shmget/mmap,见 p.20 最后一项)。别把两个层次混答。
p.28

El modelo de proceso/hebras en Unix/Linux · 多条线程调用同一过程

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

Programa principal

Programa principal:图的左侧大框,代表主程序(进程)的整体结构。

mainHebra1 … mainHebra2 … mainHebraN

框内依次是 mainHebra1、mainHebra2……mainHebraN,即主程序里的 N 条hebras。

Call proc

每条线程里都有一行 Call proc:它们都要调用同一个过程(函数)proc。

Espacio direcciones / 0x0000 / 0x0008 / 0x002A PROC

右侧橙色框是Espacio direcciones:从 0x0000、0x0008 起,到 0x002A PROC —— 过程 proc 的代码在地址 0x002A 处只有一份。

El modelo de proceso/hebras en Unix/Linux

Unix/Linux 中的proceso/hebras模型。

考点:这张图说明「代码共享,执行独立」——N 条线程都跳到同一个地址 0x002A 去执行 proc,但各自有不同的 PC 和栈,所以能同时停在同一函数的不同位置(各自一份registro de activación)。
这是「可重入(reentrante)」概念的图像版:同一函数被多线程并发调用,靠的是每条线程独立栈;若函数用了静态/全局变量,就不可重入了。
记忆钩子:「同一本菜谱,多个厨师各拿一张案板」——菜谱 = PROC 代码,案板 = 各自的栈。
p.29

Ejemplo hebras Linux · pthread 与 ps -T 实测

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

Ejemplo hebras Linux

Linux 线程示例。

long id = (long)arg;

把 void* 实参强转回 long 作为线程编号——本例不走指针,直接传整数。

printf("Hebra %ld iniciada\n", id);

打印 «Hebra %ld iniciada»(线程已启动)。

sleep(300); // 5 minutos

睡眠 300 秒,注释 «5 minutos»(5 分钟)——让线程保持存活以便观察。

printf("Hebra %ld terminada\n", id);

醒来后打印 «Hebra %ld terminada»(线程已结束)。

pthread_create(&h1, NULL, trabajo, (void*)1);

三条线程分别以 (void*)1/2/3 为参数创建——同一入口函数、不同初值(对应 p.14 的 tipo de hebra)。

pthread_join(h1, NULL); pthread_join(h2, NULL); pthread_join(h3, NULL);

主线程依次 join 三条线程,保证它们都结束后 main 才返回。

./a.out & / [1] 1614

后台运行程序,作业号 [1]、PID 1614。

ps -T -p 1614

用 ps -T -p 1614 列出该进程的所有线程。

PID SPID TTY TIME CMD / 1614 1614 pts/0 00:00:00 a.out

输出里 PID 均为 1614,而 SPID 依次为 1614、1615、1616、1617 —— 1 条主线程 + 3 条 pthread_create 线程。

考点:(1) 数线程数 = 数 ps -T 的行数(含主线程);(2) 解释 pthread_join 的必要性——不等就可能主线程先退出、整个进程结束;(3) (void*)1 这种传值方式为何不用取地址:避免 p.14 说的参数复用问题。
易错:sleep(300) 是线程各自睡,不是只睡主线程;另外 ps -T 的列名在不同发行版可能是 SPID 或 TID,指的都是线程号。
记忆钩子:「PID 一个,SPID 一排」——进程只有一张身份证,线程各有工号。
p.30

El modelo de proceso/hebras en Unix/Linux · 小结

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

En resumen:

小结:

Una hebra pertenece a un proceso y usa sus recursos

一条hebra从属于某个proceso,并使用它的资源。

Tiene su propio flujo de control independiente mientras que su proceso exista

只要其进程还存在,它就拥有独立的flujo de control。

Duplica sólo recursos esenciales

它只复制本质性的资源(寄存器、栈等最小集合)。

Pueden compartir recursos del proceso con otras hebras que también actúan de forma independiente

它可以与同样独立行动的其他线程共享进程资源。

Muere cuando su proceso padre muere

当它所属的进程(父)死亡时,它也随之死亡。

Son “ligeras”, la sobrecarga es del proceso al que pertenecen

它们是「轻量」的:sobrecarga由其所属的进程承担。

考点:这 6 句是本章「线程是什么」的标准答案骨架,几乎可整段背。若只允许答三点,选:pertenece a un proceso y usa sus recursos / flujo de control independiente / duplica sólo recursos esenciales。
陷阱:原文 «Muere cuando su proceso padre muere» 用的是 proceso padre,严格说这里指「所属进程」而非 p.12 意义上的父进程——线程与进程之间是「归属」不是「父子」。考试写 «proceso al que pertenece» 更准确。
记忆钩子:「寄生不独立」——进程在,线程活;进程亡,线程灭。开销算在宿主头上,所以叫 ligera。
p.31

POSIX · 为什么要标准化

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

POSIX (Portable Operating System Interface), desarrollado por Computer Society IEEE (IEEE-P1003)

POSIX(Portable Operating System Interface,可移植操作系统接口),由 IEEE 计算机学会制定(IEEE-P1003)。

En Unix, antes de POSIX (y de Linux) cada fabricante desarrollaba sus propias librerías para diferentes áreas del sistema operativo

在 Unix 中,POSIX(以及 Linux)出现之前,各厂商针对操作系统的不同领域各自开发自己的库。

Diferencias en los comportamientos y en las interfaces

结果导致行为与interfaces上的差异。

Con POSIX, se desarrolla un interfaz de programación estándar para resolver esas diferencias

有了 POSIX,就制定出一套标准的interfaz de programación来消除这些差异。

POSIX

POSIX(本节标题)。

考点:三件套必背——全称 Portable Operating System Interface、制定者 IEEE Computer Society(IEEE-P1003)、目的 统一各厂商库的行为与接口差异,提供标准编程接口。
记忆钩子:POSIX = 「可移植」三个字:同一份 C 代码在 Solaris、AIX、Linux 上都能编译运行,靠的就是这套标准接口。
易错:POSIX 不是「一个操作系统」也不是「一个库」,而是一组标准(见 p.32);说「Linux 实现了 POSIX」正确,说「Linux 就是 POSIX」错误。
p.32

POSIX · 标准族与覆盖范围

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

POSIX

POSIX(本节标题)。

La interfaz base se especifica originalmente en IEEE POSIX.1 (1988) con revisiones posteriores

基础接口最初规定于 IEEE POSIX.1(1988),此后多次修订。

POSIX.1-2024 es la última, siendo una actualización (sin cambios significativos) de POSIX.1-2008

POSIX.1-2024 是最新版本,是对 POSIX.1-2008 的更新(无重大变化)。

En realidad, POSIX es un grupo de estándares y cada uno cubre diferentes aspectos de los sistemas operativos compatibles con Unix incluyendo

实际上 POSIX 是一组标准,每个标准覆盖与 Unix 兼容的操作系统的不同方面,包括:

Gestión de procesos y hebras

进程与线程管理。

Entrada/salida y sistema de archivos

输入/输出与文件系统。

Manejo de señales y sincronización

信号处理与sincronización。

Utilidades de línea de comandos

命令行工具。

A partir de ese momento los vendedores ofrecen esta interfaz además de sus propias librerías

从此之后,厂商除自家库之外,还额外提供这套标准接口。

考点:年份与版本要能写——POSIX.1 首版 1988、POSIX.1-2008、POSIX.1-2024(最新,无重大变化);四个覆盖领域:procesos y hebras / E-S y ficheros / señales y sincronización / utilidades de línea de comandos。
本课程后面要用的 pthread.h(p.7、p.29)就是 POSIX 线程标准(POSIX.1c)的产物——所以讲义先讲 Unix/Linux 模型,再讲 POSIX,顺序不能颠倒。
记忆钩子:POSIX 是「一本合订本」:POSIX.1 是第一章,线程、信号、文件系统各占一节;最新一版只是换了个封皮(2024)。

三、进程的创建与表示 · PCB · 线程模型 · POSIX

p.18–p.32
p.33

POSIX(续)· pthreads 与 C11/C++11

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

POSIX

POSIX(本页标题)。

En el caso de las hebras, las implementaciones de este estándar se denominan POSIX threads o pthreads

就线程而言,该标准的实现被称为 POSIX threads(即 pthreads)。

Las funcionalidades de hebras están incluidas en POSIX.1

线程相关功能都包含在 POSIX.1 中。

Originalmente, la parte de hebras se definió en POSIX.1c y POSIX.1b contenía las extensiones de tiempo real

最初线程部分定义在 POSIX.1c 中,而 POSIX.1b 包含tiempo real扩展。

Al margen de pthreads, C11 y C++11 fueron las primeras versiones de C y C++ que introdujeron soporte estándar para concurrencia

除 pthreads 之外,C11 与 C++11 是 C 和 C++ 最早引入标准concurrencia支持的版本。

Pero pthreads sigue siendo la opción más popular (sobre todo en C)

但 pthreads 仍是最流行的选择(尤其在 C 语言中)。

考点:三个版本号对应关系——线程在 POSIX.1c,实时扩展在 POSIX.1b,两者后来都并入 POSIX.1;C/C++ 的语言级并发始于 C11 与 C++11(C 里 pthreads 仍是主流)。
记忆钩子:「1c 管线程,1b 管实时」;C11/C++11 是「官方自己下场」,但 C 程序员还是用 pthreads 这把「老牌瑞士军刀」。
本页把 p.31–p.32 的标准族收尾:pthreads 是 POSIX 线程实现的名字,后面 p.35 起的函数原型全部来自 <pthread.h>。
p.34

Ciclo de vida completo · 完整生命周期

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

Ciclo de vida completo

完整生命周期(本页标题)。

no-existe

no-existe:线程尚未诞生。

creación de una hebra

创建线程(no-existe → creada 的转移)。

creada

creada:已创建,但还没进入可执行队列。

ejecutable

ejecutable:可执行(内含 lista 与 en-ejecución 两个子状态)。

Ejec termina

执行结束(ejecutable → terminada)。

bloqueada

bloqueada:因等待事件而阻塞。

terminada

terminada:已终止,资源待回收。

Exit, cancel

退出(exit)或被取消(cancel):图中 creada、bloqueada 也有指向 terminada 的该标注。

读图顺序:no-existe →(creación de una hebra)→ creada → ejecutable ⇄ bloqueada;creada、ejecutable、bloqueada 都有通往 terminada 的路(正常结束 «Ejec termina»,或 «Exit, cancel»)。
考点:五个状态名要能默写并画出箭头;「creada 可以直接到 terminada」是容易被忽略的一条边。
记忆钩子:「无 → 生 → 跑 ⇄ 堵 → 死」五站地铁,p.35–p.42 每站配一个 API。
p.35

Estado creado · 已创建状态与 pthread_create

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

Estado creado

Estado creado(本页标题)。

#include <pthread.h>

引入 pthreads 头文件。

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg);

创建线程:thread 回填线程标识,attr 为属性,start_routine 是线程函数,arg 是传给它的参数。

Se crea una hebra que ejecuta la función “start_routine

创建一个执行函数 “start_routine 的线程(原文引号未闭合,照抄)。

int pthread_attr_init(pthread_attr_t *attr);

初始化线程属性对象。

Se definen atributos por defecto

设定atributos por defecto。

int pthread_attr_destroy(pthread_attr_t *attr);

销毁属性对象,释放其内部资源。

考点:pthread_create 四个参数顺序(thread、attr、start_routine、arg)与返回 0 表示成功;属性用 pthread_attr_init / pthread_attr_destroy 成对管理。
易错:传 NULL 作为 attr 就是「用默认属性」(见 p.43 示例中的 pthread_create(&threads[t], NULL, hebra, &id[t])),此时不必 init/destroy。
记忆钩子:「建线程四件套:我是谁(thread)、什么脾气(attr)、干什么活(start_routine)、带什么料(arg)」。
p.36

Estado creado(续)· 线程数量与无层级依赖

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

Estado creado

Estado creado(承接上页)。

El máximo número de hebras que se pueden crear depende de los recursos del sistema

可创建的线程máximo número取决于系统资源。

No hay jerarquía o dependencias entre las hebras

线程之间No hay jerarquía,也没有依赖关系。

hebra1 · hebra2 · hebra3 · hebra4 · hebra5 · hebra6 · hebra7 · hebra8 · hebra9

图中 hebra1…hebra9 九个线程彼此独立并列,没有任何父子连线。

考点:线程与进程的关键差别之一——进程有父子层级(p.12),线程之间没有;线程数上限不是固定常数,而由系统资源(内存、栈大小等)决定。
对比 p.12 的进程树:那里画的是父子孙,这里画的是「九兄弟平起平坐」。这一条也是后面 pthread_join「可 join 关系」不等于父子关系的原因。
记忆钩子:进程像家族(有族谱),线程像室友(人人平等)。
p.37

Estado creado(续)· 线程属性

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

Estado creado

Estado creado(承接上页)。

Otras funciones se utilizan para definir los atributos:

还有其他函数用于定义线程属性:

Estado “detached” o “joinable”

Estado “detached” o “joinable”:线程是分离态还是可汇合态。

Políticas de planificación

Políticas de planificación:如 FIFO、轮转等。

Parámetros de planificación

Parámetros de planificación:如优先级。

Tamaño de la pila

Tamaño de la pila。

Dirección de la pila

Dirección de la pila。

考点:线程属性五项能列举——detached/joinable、调度策略、调度参数、栈大小、栈地址;其中 detached/joinable 决定退出后资源是否要别人 pthread_join 回收。
易错:joinable 不等于「父子」。p.36 刚说过线程无层级,joinable 只是「需要有人来 join 我,回收我的退出状态」。
记忆钩子:「离不离、怎么排、排多快、栈多大、栈在哪」五连问。
p.38

Estado ejecutable · 可执行状态:lista 与 en-ejecución

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

Estado ejecutable

Estado ejecutable(本页标题)。

En un sistema monoprocesador, o cuando hay más hebras ejecutables que procesadores disponibles, como máximo una hebra puede estar en ejecución en cada procesador.

在单处理器系统中,或可执行线程数多于可用处理器时,每个处理器上como máximo只能有一个线程处于运行中。

Las demás hebras ejecutables permanecen en estado listo, esperando a que un procesador quede disponible para poder ejecutarse.

其余可执行线程停留在listo状态,等待某个处理器空出来才能运行。

creada → ejecutable → terminada · lista / En-ejecución

图中把 ejecutable 拆成 lista 与 En-ejecución 两个子状态。

考点:ejecutable 是「就绪 + 运行」的合称;「最多一个线程/处理器在运行」成立的前提是单处理器或线程多于处理器。
记忆钩子:ejecutable 是个「候车厅 + 站台」:lista 是候车厅,En-ejecución 是站台,一个站台一次只停一列车。
这页解释的是名字而不是新状态:p.34 图里的 «ejecutable» 在 p.38–p.39 被展开成 lista / En-ejecución。
p.39

Estado ejecutable(续)· 状态转换与上下文切换

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

Estado ejecutable

Estado ejecutable(承接上页)。

Una hebra pasa de lista a en-ejecución cuando el procesador se queda disponible

当处理器空出来时,线程从 lista 转入 en-ejecución。

Una hebra pasa del estado en-ejecución a lista dependiendo del tipo de planificación

线程从 en-ejecución 退回 lista,取决于tipo de planificación:

En un sistema de tiempo compartido (time-sharing) cuando se le ha acabado el tiempo de ejecución

在tiempo compartido(time-sharing)中,当其时间片用完时。

Cuando se hace ejecutable una hebra con más prioridad.

或当出现一个prioridad更高的线程变为可执行时。

El cambio de una hebra por otra en el procesador se denomina “cambio de contexto” y tiene una carga computacional.

处理器上由一个线程换为另一个线程称为“cambio de contexto”,它带有计算开销。

Hay que guardar los valores de todos los registros de la CPU, para que cuando la hebra vuelva al procesador, el cambio de contexto no haya interferido en su ejecución.

必须保存 CPU 全部寄存器的值,这样线程再回到处理器时,上下文切换不会干扰其执行。

El cambio de contexto sólo puede realizarse entre la ejecución de dos instrucciones máquina, nunca durante la ejecución de una de ellas.

上下文切换只能发生在两条instrucciones máquina之间,绝不能发生在一条指令执行的中途。

考点:进入 lista 的两种原因(时间片用完 / 更高优先级线程就绪);上下文切换要保存全部寄存器,且只能发生在指令边界。
易错:上下文切换不只是「换 PC」,而是保存全部寄存器值;「只能发生在两条指令之间」是原子性要求的经典表述。
记忆钩子:「下站台两条路:时间到、大佬来」;换人要「拍快照」(寄存器),且只能在「两句话之间」换,不能说到一半插嘴。
与 p.4 的「contexto de ejecución」呼应:那张快照包含 PC、寄存器、栈指针等,正是这里要保存的东西。
p.40

Estado Bloqueado · 阻塞状态与解除条件

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

Estado Bloqueado

Estado Bloqueado(本页标题)。

Una hebra se encuentra en un estado bloqueado cuando no puede continuar su ejecución hasta que ocurra “algún evento”.

当线程必须等到「某个事件」发生才能继续时,它就处于阻塞状态。

Bloqueos por E/S (acceso a disco o dispositivos)

因 E/S 阻塞(访问磁盘或设备)。

Bloqueos por uso de primitivas de sincronización (mutex o semáforos)

因使用primitivas de sincronización而阻塞(mutex 或semáforos)。

Para que una hebra bloqueada vuelva a estar disponible para ejecución,

要让阻塞线程重新可执行:

En el caso de completarse una solicitud de E/S el planificador del SO vuelve a poner a la hebra en el estado “lista”

若 I/O 请求完成,操作系统planificador会把线程重新置为 “lista”。

En el caso de usar primitivas de sincronización, otra hebra debe utilizar alguna primitiva específica para ello (según se usen semáforos o variables condición)

若用的是同步原语,则必须由另一个线程调用相应原语来唤醒它(视用信号量还是variables condición而定)。

El que la hebra vuelva a estar disponible no quiere decir que pase a ejecutarse de momento, sino que pasaría a la lista de hebras disponibles para ejecución

「重新可用」并不意味着马上就执行,而是进入可执行线程队列(lista)。

考点:阻塞的两大原因(E/S、同步原语);解除后一律先回 lista,不是直接运行。
易错:把 bloqueada 与 lista 混为一谈。前者在等事件,后者只等 CPU。
记忆钩子:「阻塞是等快递,就绪是等出租车」:快递到了不代表立刻走,还得排队打车。
p.41

Terminación de una hebra · 线程终止的五种情形

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

Terminación de una hebra

线程的Terminación(本页标题)。

La hebra termina cuando la función asociada a ella lo hace.

当线程所关联的函数结束时,线程就结束。

La hebra invoca a la función pthread_exit

线程主动调用 pthread_exit。

La hebra se cancela por otra hebra con pthread_cancel.

线程被另一个线程用 pthread_cancel 取消。

El proceso asociado a la hebra termina llamando a exit()

线程所属的进程调用 exit() 结束。

El “main()” termina sin llamar explícitamente a pthread_exit.

或 main() 结束且没有显式调用 pthread_exit(此时整个进程退出,所有线程随之消亡)。

考点:五条终止途径要能背——函数返回、pthread_exit、pthread_cancel、进程 exit()、main() 返回。特别注意最后一条:main 返回 = 进程结束,其它线程全没了。
易错:pthread_exit(NULL) 放在 main 末尾是「主线程退出但等其它线程」,与 return 0(进程整体结束)效果相反,正是 p.43 示例的写法。
记忆钩子:「自己走、被叫走、全家撤」——函数返回/exit 是「自己走」,cancel 是「被叫走」,进程 exit 是「全家撤」。
p.42

Terminación de una hebra(续)· pthread_exit 与 pthread_cancel

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

Terminación de una hebra

线程的终止(承接上页)。

void pthread_exit(void *value_ptr);

线程主动退出,并通过 value_ptr 交回一个退出值。

el valor apuntado por value_ptr podrá después ser recuperado con pthread_join

value_ptr 所指的值之后可由 pthread_join 取回。

int pthread_cancel(pthread_t thread);

请求取消指定线程(thread 为线程标识)。

考点:pthread_exit 返回 void、参数是 void*;pthread_cancel 返回 int、参数是 pthread_t;退出值的回收靠 pthread_join。
易错:pthread_cancel 只是「发出取消请求」,线程是否、何时响应取决于其取消状态与取消点,不是立即杀死。
p.41 的「被另一个线程 cancel」在此给出原型;p.43 的完整示例用的是 pthread_exit(NULL)。
p.43

Ejemplo Creación/Terminación · 创建与终止完整示例

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

Ejemplo Creación/Terminación

创建/终止示例(本页标题)。

#include <pthread.h> #include <stdio.h> #include <stdlib.h>

引入 pthreads、标准输入输出与通用工具三个头文件。

#define NUM_THREADS 6

宏定义线程数为 6。

void *hebra(void *threadid)

线程入口函数 hebra:参数与返回值都是 void*。

long tid; tid = *((long *)threadid);

把传入的 void* 转成 long* 再解引用,得到本线程编号。

printf(“Hola mundo! thread #%ld!\n", tid);

打印问候语与线程号(原文左引号为弯引号,照抄)。

pthread_exit(NULL);

线程主动结束,不返回退出值。

int main(int argc, char *argv[])

主函数入口。

pthread_t threads[NUM_THREADS]; int rc; long t; long id[NUM_THREADS];

线程标识数组、返回码、循环变量,以及给每个线程传参用的 id 数组。

for(t=0;t<NUM_THREADS;t++){

循环 6 次,逐个创建线程。

printf(“Creo hebra %ld\n", t); id[t]=t;

先打印「Creo hebra t」,再把编号写入 id[t]。

rc = pthread_create(&threads[t], NULL, hebra, &id[t]);

用默认属性创建线程,入口为 hebra,参数是 &id[t]。

if (rc){ printf("ERROR; codigo devuelto %d\n", rc); exit(-1); }

若返回码非 0 就打印错误并终止整个进程。

/* Ultima operacion del main*/ pthread_exit(NULL);

main 的最后一步是 pthread_exit(NULL):让主线程结束但不杀掉其它线程。

考点:示例里两个关键选择——attr 传 NULL(默认属性);main 用 pthread_exit 而不是 return,否则 main 返回会让进程结束、6 个线程全被带走。
易错:id 数组声明为 long,线程里也必须按 long* 取,否则类型不匹配;传 &id[t] 而不是 (void*)t,才是标准做法。
记忆钩子:「create 六次,exit 一次」——六个线程各喊一句 Hola mundo,主线程用 pthread_exit 在门口等着,谁也别想提前关灯。
本页把 p.35(create)、p.37(默认属性)、p.41–p.42(exit)串成可运行代码;下一批 p.44 起继续线程同步与控制。

四、线程的生命周期与 pthreads 编程

p.33–p.43

五、pthreads 实战:编译 · 参数传递 · join 与 detached

p.44–p.53
p.44

Compilación con pthreads · pthreads 的编译

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

Compilación con pthreads

使用 pthreads 的Compilación(本页标题)。

gcc miprograma.c -pthread

经典编译命令:gcc miprograma.c -pthread。

Desde la versión 2.34 no es obligatorio –pthread

从(glibc)2.34 版本起,–pthread 不再是必需的。

ldd --version para saber qué versión tenemos

用 ldd --version 查看当前系统的版本。

考点:编译命令 gcc 源文件 -pthread;glibc 2.34 之后可省略;查版本用 ldd --version。
易错:是 -pthread(一个连字符),老写法 -lpthread 是链接库;两者语义不同,讲义给的是前者。
记忆钩子:「2.34 之前要举手申请(-pthread),之后默认放行」;不放心就先 ldd --version 看一眼。
编译通过后,p.45–p.46 用参数传递示例、p.47 起用 join 示例继续练手。
p.45

Paso de parámetros · 参数传递(线性查找示例)

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

Paso de parámetros

Paso de parámetros(本页标题)。

#include <pthread.h> #include <stdio.h>

引入 pthreads 与标准 I/O 头文件。

struct argm { int x; int v[10]; int li; int lf; };

自定义结构体 argm:待查值 x、数组 v[10]、查找区间 li 与 lf。

void *búsqueda_lineal(void *argg ){

线程入口 búsqueda_lineal(线性查找),参数为 void*。

int i=0, pos=-1, enc=0;

局部变量:下标、位置(初值 −1)、是否找到的标志 enc。

struct argm *arg; arg=(struct argm *) argg;

把 void* 强转为 struct argm*,得到参数结构体指针。

i=arg->li;

从区间下界 li 开始查找。

while (i<=arg->lf && !enc) {

只要没超过上界且还没找到就继续循环。

if ((arg->v[i])==(arg->x)) enc=1; else i++;

命中则置 enc=1,否则下标加一。

if (enc) printf("Encontrado en pos =%d\n", i);

若找到就打印位置。

void rellenar( int* x){ int i=0; for (i=0;i<10;i++) { x[i]=i; } }

辅助函数:把数组填成 0…9。

考点:pthread 只能传一个 void*,所以多个参数要打包成 struct再传地址;线程里必须强转回原类型。
易错:示例里 pos 声明后没用,且 búsqueda_lineal 缺 return(返回类型 void*);考试若让指出问题,这两处是原文的瑕疵。
记忆钩子:「一个口袋(void*)装一包东西(struct)」——参数多了就打包裹,进线程再拆包。
p.46

Paso de parámetros(续)· main 中的创建与 join

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

Paso de parámetros

Paso de parámetros(承接上页)。

int main () { struct argm arg, arg2; pthread_t th1,th2; pthread_attr_t attr; int val=1;

main 中声明两份参数结构体、两个线程标识、一个属性对象,以及 val。

rellenar(arg.v); rellenar(arg2.v);

给两份数组都填入 0…9。

arg.li=0; arg.lf=4; arg.x=1; ………

为第一份设定查找区间 [0,4] 与待查值 1;省略号处对 arg2 做类似设置。

pthread_attr_init(&attr);

初始化线程属性对象(atributos por defecto)。

pthread_create(&th1,&attr,búsqueda_lineal,&arg);

创建 th1,用刚初始化的属性,参数是 &arg。

pthread_create(&th2,&attr,búsqueda_lineal,&arg2);

创建 th2,参数是 &arg2。

pthread_join (th1,NULL); pthread_join (th2,NULL);

主线程分别等待 th1、th2 结束(不接收退出值)。

printf("Fin\n"); return 0;

打印 «Fin» 后正常返回。

考点:多线程传参的完整套路——每线程一份独立的 struct(arg / arg2),create 传各自地址,最后 join 收尾。
易错:如果两个线程共用同一个 struct,就会互相踩数据;本页特意用 arg 与 arg2 两份。
记忆钩子:「一人一个饭盒」——两个线程两盒参数,别共用一个。
p.47

La función join · join 函数

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

La función join

La función join(本页标题)。

Una hebra puede esperar (en estado bloqueado) a que otra hebra termine llamando a join sobre esta otra hebra.

一个线程可以对另一个线程调用 join,从而(以阻塞状态)等待后者结束。

Es un mecanismo de sincronización entre hebras.

这是一种线程间的mecanismo de sincronización。

Existen otras alternativas que veremos más adelante

还有其他替代机制,后面再讲。

La función pthread_join()bloquea la hebra hasta que la hebra que se indica en su parámetro no termine.

pthread_join() 会把调用线程阻塞,直到其参数所指的线程结束(原文 «no termine» 多了一个 no,照抄)。

考点:join 的两重身份——等待(阻塞调用者)+同步机制;调用后调用者进入 bloqueado(p.40)。
易错:原文 «hasta que … no termine» 是西班牙语否定赘余(应为 «hasta que … termine»),语义是「等到它结束」,别理解反。
记忆钩子:join = 「等你下班我再走」;被 join 的线程是 joinable 的(p.49 细讲)。
p.46 已在用 pthread_join,本页给出概念,p.49 给原型,p.50–p.52 给完整 joinable 示例。
p.48

Ejemplo suma vector · 向量求和的 join 示例

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

Ejemplo suma vector

向量求和示例(本页标题)。

#include <pthread.h> #include <stdio.h>

引入所需头文件。

struct argm { int *v; int li; int lf; int suma; };

参数结构体:数组指针、区间下界、上界,以及存放部分和的 suma。

void *sumar(void *argg) {

线程入口 sumar。

struct argm *arg = (struct argm *) argg; int i;

拆包:把 void* 还原成 struct argm*。

arg->suma = 0;

部分和清零。

for (i = arg->li; i <= arg->lf; i++) { arg->suma += arg->v[i]; }

只累加 [li, lf] 区间内的元素。

return NULL;

线程正常返回(等价于退出值为 NULL)。

int main() { int v[10] = {1,2,3,4,5,6,7,8,9,10}; pthread_t h1, h2;

main 中定义 1…10 的数组与两个线程标识。

struct argm a1 = {v, 0, 4, 0}; struct argm a2 = {v, 5, 9, 0};

把数组切成两半:[0,4] 给 a1,[5,9] 给 a2。

pthread_create(&h1, NULL, sumar, &a1); pthread_create(&h2, NULL, sumar, &a2);

用默认属性创建两个求和线程。

pthread_join(h1, NULL); pthread_join(h2, NULL);

等两个线程都算完。

printf("Suma total = %d\n", a1.suma + a2.suma); return 0;

把两个部分和相加打印,即 55。

¿Qué obtenemos si no esperamos a que las hebras terminen?

页面右下提问:如果不等待线程结束,会得到什么结果?

考点:本例是「分治 + join」的模板——数组切两段、两个线程各算部分和、join 后合并。去掉 join 就可能读到未写完的 suma(脏读)。
易错:两个线程写的是不同的 suma 字段(a1 / a2),所以无需加锁;若共享同一个累加变量就必须同步。
记忆钩子:「先 join 再相加」——不等就加,等于菜没熟就揭锅。
p.49

Joinable vs detached · 可汇合与分离

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

Joinable vs detached

Joinable 与 detached 的对比(本页标题)。

int pthread_join(pthread_t thread, void **value_ptr);

等待线程结束:thread 指定目标线程,value_ptr 用于接收退出值。

value_ptr permitirá recuperar el valor utilizado con pthread_exit o el return de la hebra (si no se hace pthread_exit)

value_ptr 可取得线程经 pthread_exit 交回的值,或(未调用 pthread_exit 时)return 返回的值。

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

读取属性对象中的分离状态。

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

设置属性对象中的分离状态。

PTHREAD_CREATE_DETACHED, PTHREAD_CREATE_JOINABLE

两个合法取值:PTHREAD_CREATE_DETACHED 与 PTHREAD_CREATE_JOINABLE。

考点:joinable 线程退出后要由别人 pthread_join 回收;detached 线程退出时资源自动回收,不能 join。两个常量名与 get/set 两个函数名要能拼写。
易错:对 detached 线程调用 join 会失败;反过来,joinable 线程没人 join 就会残留资源(类似进程里的 zombie,p.16)。
记忆钩子:「joinable = 等人收尸;detached = 自行火化」。
p.50

Joinable vs detached(续)· 显式设为 joinable 并创建

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

Joinable vs detached

Joinable vs detached(承接上页)。

#include <pthread.h> #include <stdio.h> #include <stdlib.h>

三个头文件。

#define NUM_THREADS 10

线程数宏定义为 10(原文换行排版,照抄数值)。

int main (int argc, char *argv[]) {

主函数入口。

pthread_t thread[NUM_THREADS]; pthread_attr_t attr; int rc, id[NUM_THREADS]; long t; void *status;

线程标识数组、属性对象、返回码与编号数组、循环变量、退出值指针。

/* Incializamos y ponemos explicitamente el atributo a joinable*/

注释:初始化属性,并显式设为 joinable(原文 Incializamos 少一个 i,照抄)。

pthread_attr_init(&attr);

初始化属性对象。

pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

把分离状态设为 PTHREAD_CREATE_JOINABLE。

for(t=0; t<NUM_THREADS; t++) {

循环创建 10 个线程。

printf(“Creamos hebra %ld\n", t); id[t]=t;

打印「Creamos hebra t」,并记录编号。

rc = pthread_create(&thread[t], &attr,func_hebra, (void *)&id[t]);

用设定好的属性创建线程,入口 func_hebra,参数为 &id[t]。

if (rc) { printf("ERROR: pthread_create() is %d\n", rc); exit(-1); }

创建失败则打印错误码并退出进程。

Y si cambiamos el atributo?

页面右下提问:如果把属性改掉(改成 detached)会怎样?

考点:显式 joinable 的三步——attr_init → attr_setdetachstate(PTHREAD_CREATE_JOINABLE) → create 传 &attr;注意与 p.43 示例直接传 NULL 的区别。
易错:id 传的是 (void *)&id[t],仍是地址;若改成 (void *)t,线程里就必须按整数解释,两者不能混。
记忆钩子:「先表态(setdetachstate),再出生(create)」——线程的性格在出生前就定好。
p.51

Joinable vs detached(续)· 回收与退出值

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

Joinable vs detached

Joinable vs detached(承接上页)。

…desde la diapositiva anterior

……接上一页(代码续)。

/* Esperamos la terminacion de las hebras */

注释:等待各线程结束。

pthread_attr_destroy(&attr);

属性用完即销毁(创建阶段已结束)。

for(t=0; t<NUM_THREADS; t++) { rc = pthread_join(thread[t], &status);

逐个 join,并把退出值存入 status。

if (rc) { printf("ERROR pthread_join() is %d\n", rc); exit(-1); }

join 失败则报错退出。

printf(“Fin thread %ld estado %ld\n",t,(long)status);

打印线程号与其退出状态(把 void* 转成 long)。

printf(“Fin main.\n"); pthread_exit(NULL); }

打印 «Fin main.» 后主线程以 pthread_exit(NULL) 收尾(不是 return)。

考点:join 的第二个参数 void** 用来取回退出值,本例把 status 强转 long 打印;attr_destroy 在 create 之后、join 之前即可。
易错:status 是 void*,打印要用 (long)status;若传 NULL 表示不关心退出值(p.46、p.48 就是 NULL)。
记忆钩子:「join 两手抓:等人到(阻塞)+ 收遗言(status)」。
p.52

Joinable vs detached(续)· func_hebra 线程函数

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

Joinable vs detached

Joinable vs detached(承接前两页)。

void *func_hebra(void *t) { int i; long tid; double result=0.0;

线程函数:局部变量 i、线程号 tid、累加结果 result。

tid = *((long *) t);

解引用参数,取回线程号。

printf("Thread %ld empieza...\n",tid);

打印「Thread tid empieza...」(开始)。

if (tid%2==0) {

偶数号线程走第一支:

for (i=0; i<1000000; i++) { result = result + i; }

累加 0…999999(较轻的活)。

}else { for (i=0; i<2000000; i++) { result = result + i; }}

奇数号线程累加 0…1999999(两倍的活),用来制造不均衡负载。

printf("Thread %ld hecho. Resultado = %e\n",tid, result);

打印「Thread tid hecho. Resultado = …」(已完成)。

pthread_exit((void*) t);

把传入的 t 原样作为退出值交回(供 p.51 的 status 接收)。

考点:退出值就是 pthread_exit 的参数,本例把线程号 t 当退出值;因此 p.51 打印的 estado 正是各线程号。奇偶分支造成负载不均,便于观察 join 的等待效果。
易错:%e 是科学计数法,result 是 double;若用 %d 打印就是未定义行为。
记忆钩子:「偶数十万,奇数二十万」——奇数线程干双倍活,主线程 join 时必须等最慢的那个。
p.53

En resumen… · 本章小结

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

En resumen…

小结……(本页标题)。

Necesitamos nuevas abstracciones para la programación concurrente:

我们需要新的抽象来支撑programación concurrente:

Procesos

Procesos。

Hebras

Hebras。

En nuestro caso, vamos a utilizar POSIX con C y hebras

本课程选用 POSIX + C + 线程。

Debemos conocer bien cómo funciona la creación de hebras, el paso de parámetros y la sincronización con su finalización

必须熟练掌握三件事:creación de hebras、paso de parámetros,以及用sincronización con su finalización(join)。

考点:本章三件套背诵——创建(pthread_create)、传参(struct + void*)、同步终止(pthread_join / joinable);技术栈是 POSIX + C + 线程。
这三件事正是 p.35、p.45–p.46、p.47–p.52 的主线;下一章(Tema 3)将在此之上讲互斥与同步原语。
记忆钩子:「生(create)— 喂(参数)— 送(join)」线程三连。

专有名词速记表(A–Z)

共 114 条,覆盖全 53 页的高频术语。第三列点页码直接跳回原页;最后一列只写「一句话 + 最容易被扣分的点」。

西语术语中文页码一句话记住 · 易错点
#
“cambio de contexto”上下文切换p.39换线程=保存全部寄存器再恢复;只能发生在两条机器指令之间,不能一条指令执行到一半就换。
线程号 TID线程号p.25top -H / ps -T 里每行一个线程,SPID 就是 TID;同一进程内各线程 TID 不同。
A
aislamiento隔离p.4进程之间地址空间相互隔离;线程之间不隔离,共享同一地址空间。
atributos por defecto默认属性p.35pthread_create 第 2 参数传 NULL 即默认属性;要自定义就先 attr_init 再填。
B
bloqueada阻塞p.34等事件(E/S 或同步原语);事件到来只回 lista,不会直接跳到运行。
C
código de salida退出码p.17wait(&status) 后用 WEXITSTATUS(status) 取;只有正常终止时才有意义。
como máximo最多p.38「每个处理器最多一个线程在运行」的前提是单核,或可运行线程多于核。
Compilación编译p.44gcc miprograma.c -pthread;glibc 2.34 起可省略,版本用 ldd --version 查。
Comunicación entre procesos进程间通信p.20PCB 之外的另一类进程信息:管道、信号、共享内存、信号量都算 IPC。
concurrencia并发p.1多个控制流在时间上重叠;并发不等于并行,并行还要求多核同时执行。
contador de programa程序计数器p.6PC 指向下一条待执行指令;每个线程各有一份,属于私有上下文。
contador del programa程序计数器p.24p.24 的另一种写法;线程私有寄存器清单的第一项。
contexto de ejecución执行上下文p.4寄存器+PC+栈指针等构成的一张快照;切换线程时整张保存、整张恢复。
corrutina协程p.9用户态协作式让出,没有内核抢占;不要与操作系统的抢占式线程混为一谈。
creación de hebras线程创建p.53pthread_create:函数指针+void* 参数;创建完只是 creada,是否运行看调度器。
Creación dinámica动态创建p.10运行期间按需创建(fork、pthread_create);与之相对的是初始创建。
creación explícita显式创建p.19直接调用创建函数或 new 一个线程对象,代码里看得见「创建」这个动作。
Creación inicial初始创建p.10程序启动时就存在的那组进程/线程,静态确定,不靠运行中再创建。
creada已创建p.34生命周期第二站:对象已存在但还没进入就绪队列;属性已在此时定好。
D
descriptores de fichero文件描述符p.12fork 后父子共享同一批打开文件,文件偏移也共享;这是易考的继承点。
detached分离p.49退出即自动回收,不能 join;常量是 PTHREAD_CREATE_DETACHED。
Dirección de la pila栈地址p.37线程属性之一;需要自己提供栈区时才设置,默认由系统分配。
directorio de trabajo工作目录p.20PCB 记录的进程信息之一;fork 子进程继承父进程的当前目录。
E
E/S输入/输出p.40阻塞的两大来源之一;I/O 完成后由 OS 调度器把线程放回 lista。
ejecutable可执行p.34它是 lista 与 En-ejecución 的合称,不是单一状态。
En-ejecución运行中p.38真正占用 CPU 的子状态;一个核同一时刻最多一个。
entorno环境p.12环境(变量表);fork 复制一份,exec 默认原样保留。
Espacio de dirección del usuario用户地址空间p.26p.26 图里线程共享的那一大块;代码、数据、堆都在一起。
espacio de direcciones地址空间p.4进程私有;同一进程的所有线程共用同一份。
Espacio direcciones地址空间p.28p.28 图标题的简写;图中标出共享区与各线程私有栈。
estado终止状态p.17wait 取回的状态字;用 WIFEXITED / WEXITSTATUS 等宏解析,不能直接当退出码。
Estado Bloqueado阻塞状态p.40等 E/S 或 mutex/信号量;被唤醒后进 lista,仍要排队等 CPU。
Estado creado已创建状态p.35刚 create、尚未被调度;detached/joinable、优先级等属性在此确定。
Estado ejecutable可执行状态p.38含 lista 与 En-ejecución;何时切换取决于调度策略与优先级。
Estado “detached” o “joinable”分离 / 可汇合p.37线程属性五项之首;决定退出后资源是否需要别人 join 回收。
Explícita显式表示p.18语言提供专门的 constructor 来描述进程/线程(如 extends Thread)。
F
finalización终止p.16终止分正常(exit/return)与异常(信号)两路;父进程都要 wait 收尸。
flujo de control控制流p.4一条指令执行序列;线程就是进程内部的多条控制流。
H
heap堆p.4动态分配区,进程内共享;多线程同时 malloc 需要注意线程安全。
hebra线程p.1进程内的执行流,共享地址空间、私有栈与寄存器。
hebras线程p.2复数形式;本课程用 POSIX 的实现,叫 pthreads。
I
Implícita隐式表示p.18用普通函数/方法界定线程代码,如今更常见;与「专门的 constructor」相对。
instrucciones máquina机器指令p.39上下文切换只能发生在两条之间,不能打断一条指令的执行。
interfaces接口p.31POSIX 规定的是接口(API),不是具体实现;厂商各自实现。
interfaz de programación编程接口p.31即 API;POSIX 就是一组标准化的编程接口,不是某个库的名字。
J
Jerarquía de procesos进程层级p.2进程有父子树(p.12);线程之间没有层级,别把两者混用。
Joinable可汇合p.49默认形态,退出后等别人 pthread_join 回收;无人 join 会残留资源。
L
La función joinjoin 函数p.47阻塞调用者直到目标线程结束,同时取回退出值;它本身就是一种同步机制。
Las hebras线程p.23p.23 标题:线程在进程内部运行,由 OS 调度。
librerías compartidas共享库p.20映射进地址空间的 .so;fork 后父子共享代码段,写时复制数据段。
lista就绪p.38就绪队列,只等 CPU;与「等事件」的 bloqueada 有本质区别。
listo就绪p.38p.38 正文用的形容词形式,与 lista 同义。
load average平均负载p.21top 首行三个数:1、5、15 分钟平均负载,可运行+不可中断进程数。
M
máximo número最大数量p.36可创建线程数上限由系统资源决定,不是固定常数。
mecanismo de sincronización同步机制p.47join 是最简单的线程同步;后续还有 mutex、信号量、条件变量。
memoria compartida共享内存p.20线程间默认共享(p.27 图);进程间要显式申请 shm 段。
multithreading多线程p.6一个进程内多个执行流;相对多进程更轻,但共享带来同步问题。
N
No hay jerarquía没有层级关系p.36线程之间无父子、无依赖;joinable 只是「需被回收」而非从属关系。
no-existe不存在p.34生命周期起点;创建动作把 no-existe 变成 creada。
núcleos核心p.10核数决定真正并行度;线程数超过核数就只能分时复用。
O
operación asíncrona异步操作p.8发起后不阻塞等待结果,完成时再通知或回调;与同步调用相对。
P
Parámetros de planificación调度参数p.37如优先级数值,必须与调度策略(policy)配合设置才有意义。
Paso de mensajes消息传递p.14通过管道等把数据交给新进程,是初始化的两条路线之一(另一条是参数传递)。
Paso de parámetros参数传递p.14pthread_create 第 4 参数只能是一个 void*,多参数要打包成 struct 传地址。
patrón模式p.14固定套路,如 fork+exec、生产者-消费者;答题时先点名模式再展开。
PCB进程控制块p.20OS 记录进程全部信息的结构(p.20 列了 11 组信息),进程的「档案袋」。
PID进程号p.5进程唯一标识;fork 后子进程 PID 不同,getpid() 可取。
pila栈p.4线程私有,存局部变量与调用链;大小可通过属性设置。
planificadas调度p.23被操作系统选中执行;创建不等于被调度。
planificador调度器p.18决定下一个谁上 CPU;创建完是否立刻运行由它说了算,不是 create 决定。
política调度策略p.24如 FIFO、轮转;与优先级参数成对出现,写进线程私有属性。
Políticas de planificación调度策略p.37线程属性五项之一;实时系统里这一项尤其关键。
pool线程池p.19预先创建一批线程反复复用,避免频繁 create 的开销(隐式表示常用)。
POSIXPOSIX 标准p.31一组 IEEE 标准;基础接口 POSIX.1(1988),最新 POSIX.1-2024 无重大变化。
POSIX threadsPOSIX 线程p.33即 pthreads;线程部分最初在 POSIX.1c,实时扩展在 POSIX.1b。
primitivas de sincronización同步原语p.40mutex、信号量、条件变量;阻塞的第二大来源,唤醒要别的线程动手。
prioridad优先级p.24高优先级线程一旦就绪,可能把当前线程赶回 lista(p.39)。
proceso进程p.1运行中的程序实例,拥有独立地址空间与资源;并发的基本抽象之一。
proceso hijo子进程p.5fork 的产物,继承父进程资源但有自己的 PID,退出后要靠父进程 wait。
proceso ligero轻量级进程p.8线程的另一种叫法;切换开销比进程小,因为不换地址空间。
procesos进程p.1复数;另一种并发抽象是线程(hebras)。
Process ID进程号p.20PCB 中的 PID 字段;ps/top 第一列就是它。
programación concurrente并发编程p.53需要进程/线程等新抽象;本课程路线是 POSIX + C + 线程。
PTHREAD_CREATE_DETACHED分离态p.49传给 pthread_attr_setdetachstate 的常量;设了它就不能再 join。
PTHREAD_CREATE_JOINABLE可汇合态p.49默认可 join;p.50 示例显式设置它,再在 p.51 逐个 join。
pthreadspthreads 线程库p.33POSIX 线程实现;C11 有了标准线程后,C 里它仍是主流。
Puntero a pila栈指针p.26ESP/RSP 之类,指向当前栈顶;线程私有,切换时必须保存。
R
registro de activación活动记录p.28即栈帧,每次函数调用生成;p.28 图中可见其在栈上的位置。
Registros寄存器p.4CPU 寄存器组;上下文切换必须全部保存,少存一个都可能算错。
relación padre/hijo父子关系p.12由 fork 建立;父进程负责 wait 回收子进程的退出状态。
representación explícita显式表示p.19Java 的 class X extends Thread 就是代表,语言有专门构造。
representación implícita隐式表示p.19用 lambda/函数交给 pool.submit,代码里没有线程类。
running运行中p.21top 的 R 状态;与讲义里的 En-ejecución 对应。
S
semáforos信号量p.20同步原语,P/V 操作;也是线程阻塞的常见原因。
señales信号p.20进程收到的异步通知(如 SIGKILL);PCB 中记录待处理/被阻塞信号。
sincronización同步p.32协调多个执行流的顺序;POSIX 覆盖领域之一。
sincronización con su finalización终止同步p.53用 join 等线程结束,p.53 三件套之一。
sistemas de tiempo real实时系统p.10有截止期约束,倾向静态/初始创建,避免运行中创建带来的不确定性。
sobrecarga开销p.30创建线程、上下文切换都有成本;线程比进程轻,但不是零成本。
T
Tamaño de la pila栈大小p.37线程属性之一;线程多时栈总和会吃掉地址空间。
Tarea任务p.8Ada 的 task、Python 的 asyncio task;并发抽象的第三种叫法。
tareas任务p.3p.3 列出的概念之一;答题时先区分进程/线程/任务三种抽象。
task type任务类型p.9Ada 中定义任务的类型,可声明多个 task 实例。
terminación终止p.12进程/线程的结束;父进程(或 join)负责回收。
terminación con éxito正常终止p.16exit(0) 或 main 返回 0;wait 后 WEXITSTATUS 为 0。
terminación con fallo异常终止p.16exit(非 0) 或被信号杀死;后者 WIFEXITED 为假,不能读退出码。
terminada已终止p.34生命周期终点;joinable 线程此时等 join 回收,detached 自动回收。
tiempo compartido分时系统p.39时间片轮转;时间片用完就回 lista,这是最常见的让出原因。
tiempo real实时p.33实时扩展最初在 POSIX.1b;与「分时」相对,强调截止期。
tipo de planificación调度类型p.39决定线程何时从运行退回 lista 的依据。
tipo de proceso/hebra进程/线程类型p.14创建时需要指定的类型信息,影响后续资源与调度。
V
variables condición条件变量p.40与 mutex 配合,在条件不满足时阻塞、被 signal/broadcast 唤醒。
Variables de entorno环境变量p.20PCB 记录的信息之一;fork 继承,exec 默认保留。
Z
zombie僵尸进程p.21已终止但父进程未 wait 的进程,top 中显示为 Z;父进程回收后消失。

数量速记卡(考卷里的「列举 N 项」)

口诀:一核一线程 · 二因二态二法二模 · 三规范 · 四参数 · 五态五属性五终止 · 十一组 PCB。下表「数量」列就是题干里的 N,右侧页码点回原页。

数量原文关键词中文性质归类页
1como máximo una hebra puede estar en ejecución en cada procesador每个处理器最多一个线程在运行调度事实(单核或线程多于核时成立)p.38
2Bloqueos por E/S / por uso de primitivas de sincronización阻塞的两个成因:I/O、同步原语状态迁移原因p.40
2joinable o detached可 join / 已分离两种线程属性线程属性(决定能否回收)p.49
2Creación inicial / Creación dinámica程序启动即建 / 运行中按需建创建时机模型p.10
2creación explícita / representación implícita显式创建 / 隐式(交给池)创建方式p.19
3POSIX.1c · POSIX.1b · C11线程定义来源与实时扩展、C 语言标准规范来源p.33
4pthread_create 的四个形参线程句柄 / 属性 / 入口函数 / 参数函数签名(背原型)p.35
5no-existe · creada · ejecutable · bloqueada · terminada不存在 / 已创建 / 可执行 / 阻塞 / 已终止完整生命周期状态机p.34
5detached/joinable · políticas · parámetros · tamaño de pila · dirección de pila五项可设属性属性清单p.37
5return · pthread_exit · pthread_cancel · exit() · main 未调 pthread_exit线程终止的五条途径终止方式p.41
11Información asociada al proceso en el PCBPCB 的 11 组信息进程档案字段p.20

最容易混的 14 组概念

每张卡只回答一件事:差别落在哪一个词上。答题时先把那个词说出来,再展开。

proceso / hebra进程有独立地址空间(代码、数据、堆、栈全私有);线程共享所属进程的地址空间,只私有一份寄存器与栈。
concurrencia / paralelismo并发=多个控制流在时间上重叠(单核也能);并行=同一时刻真在多核上同时执行。
joinable / detachedjoinable 能被别的线程 pthread_join 回收并取退出值;detached 设了就不能再 join,退出即自动回收。
pthread_exit / exitpthread_exit 只结束当前这一条线程;exit 结束整个进程,所有线程一起没。
pthread_cancel / pthread_exitcancel 是别的线程发取消请求;exit 是线程自己主动退出。
fork / pthread_createfork 复制出独立进程(地址空间隔离);pthread_create 在同一进程内加一条执行流(地址空间共享)。
creada / listacreada=对象已建好、属性已定,但还没进就绪队列;lista=已就绪、只等处理器。
bloqueada / listabloqueada 等的是事件(I/O 完成、信号量/互斥量);lista 等的是处理器。
PCB / contexto de ejecuciónPCB 是进程的整份档案(11 组信息);上下文只是切换时保存恢复的寄存器快照。
política de planificación / estado del planificador前者是规则(怎么挑下一个);后者是当前值(优先级、剩余时间片等)。
atributos por defecto / pthread_attr_initpthread_create 第 2 参数传 NULL 就走默认属性;要自定义必须先 attr_init 再 set,用完 destroy。
creación inicial / creación dinámica初始创建在程序启动时一次建好(实时系统便于做时序分析);动态创建在运行中按新请求再建。
«hasta que … no termine»西语否定赘余:字面「直到不结束」,实际语义是「直到结束为止」,不要翻反。
zombie / terminadaterminada 是状态;zombie 是已终止但父进程还没 wait 的残留项,top 里显示 Z。