先读这一段 / 入口函数与创建调用

先写工作函数，再把函数交给新线程执行

你记忆中的流程是正确的：先定义线程入口函数，再把它的函数名传给pthread_create。新线程从这个入口开始执行，入口返回后，该工作线程结束。worker只是示例名字，可以换成其他合法函数名，函数签名必须符合接口。

void *worker(void *arg)
{
    /* 新线程要做的工作 */
    return NULL;
}

两个 void * 分别表示什么？

位置	实际含义
`void worker`前面的`void `	返回值类型：函数可以返回一个指针，供join者取得；不需要交回结果时可以return NULL。不是说工作函数本身是一个普通void*变量。
`(void *arg)`	唯一参数的类型：接收创建时传入的一个地址值；线程内部根据真实对象类型解释它，例如`int id = (int )arg;`。
`void ()(void *)`	“接收一个void、返回void的函数指针类型”，是pthread_create第三参数需要的类型。不要用强制转换掩盖不兼容的入口签名。

pthread_create 的四个实参，逐个对上

pthread_create(&tid, NULL, worker, &id);
/*              ①     ②      ③      ④  */

实参	作用
① `&tid`	线程标识的输出地址，创建成功后tid记录新线程标识。函数本身返回的int rc是错误状态，不是线程标识。
② `NULL`	使用默认创建属性。
③ `worker`	提供入口函数地址；函数名在此转换成函数指针，写`&worker`也可。
④ `&id`	把id的地址交给新线程，该地址就是worker中arg收到的值。

为什么写 worker，而不是 worker()？

worker在此提供函数地址，让新线程稍后从该函数执行。worker()是立即调用函数的表达式；对于本例还缺少必需参数。即使写成worker(&id)，也会先在当前调用线程执行worker，再把它返回的void*当第三参数，既不是所需函数指针，也没有表达由新线程执行工作。

主线程定义并准备id → create传入worker与&id → join等待

新线程执行worker(arg)，arg为传入的&id → 读取任务编号 → return NULL

这是逻辑关系图，不是严格调度顺序：新线程可能在pthread_create返回前已开始执行；不能推断所有工作都等到主线程调用join才开始。

最小可运行程序：新线程打印任务编号7

id只在创建前赋值，线程使用期间主线程不改它；main在return前先join，所以参数对象仍存活。传地址并不会自动复制id，若改成循环共享同一个&i，还需要独立参数槽位等设计。

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

static void *worker(void *arg)
{
    int id = *(int *)arg;
    printf("worker: task id=%d\n", id);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    int id = 7;

    int rc = pthread_create(&tid, NULL, worker, &id);
    if (rc != 0) {
        fprintf(stderr, "pthread_create: %s\n", strerror(rc));
        return 1;
    }

    rc = pthread_join(tid, NULL);
    if (rc != 0) {
        fprintf(stderr, "pthread_join: %s\n", strerror(rc));
        return 1;
    }
    return 0;
}

cc -std=c11 -Wall -Wextra -Werror -pthread pthreads_entry.c -o pthreads_entry
./pthreads_entry
# 输出：worker: task id=7

pthread_join(tid, NULL)等待目标线程结束，但忽略它的返回指针；它不会负责启动工作函数，也不是终止命令。入口中的return NULL表示不交回结果指针，不代表创建失败。

已用本机Apple clang17严格警告编译并执行。课件对应第四章第14–20页；接口核验：POSIX pthread_create、pthread_join。

PTHREADS / FROM MAIN TO JOIN

从一份能运行的程序开始

POSIX线程（POSIX Threads，Pthreads）让一个进程内的多个执行流共享地址空间。你要显式创建线程、传入参数、协调共享访问，再等待结束。对应第四章第7–20、25–38页。

先掌握六个接口：pthread_create、pthread_join以及pthread_mutex_init/lock/unlock/destroy。之后再学习条件变量、读写锁和信号量。

/* 线程入口的固定形状 */
void *worker(void *arg) {
    /* 把arg解释为自己的参数结构体指针，执行计算 */
    return NULL;
}

/* main的组织方式：先创建全部线程，再等待全部线程 */
pthread_mutex_init(&mutex, NULL);
for (int t=0; t<thread_count; ++t)
    pthread_create(&threads[t], NULL, worker, &tasks[t]);
for (int t=0; t<thread_count; ++t)
    pthread_join(threads[t], NULL);
pthread_mutex_destroy(&mutex);

上面是结构示意，变量需声明，调用需检查返回值。下面的完整源码包含声明、任务划分、参数生命周期和失败处理，可直接编译运行。

主线程准备参数 → create各worker → join各worker → 清理

工作线程收到自己的Task* → 局部计算 → 安全合并 → return

与MPI区别：Pthreads不需要Init/Finalize，也没有自动分配的rank。需要任务编号时自己在Task.id里保存。pthread_t是线程标识，Task.id才是示例中的0、1、2、3。

基础框架，分六步读懂

每一步都围绕完整求和程序，不是孤立地背函数名。

完整例子：4线程求1到1003的和

每线程收到一个独立Task，处理半开区间[begin,end)，在局部累积，写到自己的partial，然后短暂持锁更新共享总和。主线程join后取得返回指针并再次汇总，可同时检查两种结果。

本例同时展示两种合并思路。若只保留“每线程写独立partial，主线程join后合并”，可以省掉shared_sum及互斥锁；若worker直接合并共享总和，则必须协调共享更新。

cc -std=c11 -Wall -Wextra -pthread pthreads_sum.c -o pthreads_sum
./pthreads_sum

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

#define THREADS 4
#define N 1003

typedef struct {
    int id;
    int begin, end;              /* half-open interval [begin, end) */
    const long long *values;    /* shared read-only array */
    long long partial;          /* only this worker writes this field */
} Task;

static pthread_mutex_t sum_mutex;
static long long shared_sum = 0;

static void check(int rc, const char *operation) {
    if (rc != 0) {
        fprintf(stderr, "%s: %s\n", operation, strerror(rc));
        exit(EXIT_FAILURE);     /* fatal error: end the whole process */
    }
}

/* Required entry signature: void *worker(void *arg). */
static void *worker(void *arg) {
    Task *task = arg;            /* pthread_create passes this pointer */
    long long local = 0;         /* private automatic variable */
    for (int i = task->begin; i < task->end; ++i)
        local += task->values[i];
    task->partial = local;

    check(pthread_mutex_lock(&sum_mutex), "mutex_lock");
    shared_sum += local;        /* short, protected shared update */
    check(pthread_mutex_unlock(&sum_mutex), "mutex_unlock");

    /* Points into main's still-live Task array, NOT worker's local. */
    return &task->partial;
}

int main(void) {
    long long values[N];
    for (int i = 0; i < N; ++i) values[i] = i + 1;
    pthread_t threads[THREADS];
    Task tasks[THREADS];
    check(pthread_mutex_init(&sum_mutex, NULL), "mutex_init");

    int created = 0;
    for (int t = 0; t < THREADS; ++t) {
        tasks[t] = (Task){t, N * t / THREADS, N * (t + 1) / THREADS,
                         values, 0};
        int rc = pthread_create(&threads[t], NULL, worker, &tasks[t]);
        if (rc != 0) {
            fprintf(stderr, "pthread_create: %s\n", strerror(rc));
            break;             /* join only the successfully created ones */
        }
        ++created;
    }

    long long joined_sum = 0;
    int ok = created == THREADS;
    for (int t = 0; t < created; ++t) {
        void *returned = NULL;
        check(pthread_join(threads[t], &returned), "pthread_join");
        if (returned != &tasks[t].partial) ok = 0;
        else joined_sum += *(long long *)returned;
        printf("task=%d range=[%d,%d) partial=%lld\n", tasks[t].id,
               tasks[t].begin, tasks[t].end, tasks[t].partial);
    }
    check(pthread_mutex_destroy(&sum_mutex), "mutex_destroy");
    long long expected = (long long)N * (N + 1) / 2;
    ok = ok && joined_sum == expected && shared_sum == expected;
    printf("joined_sum=%lld shared_sum=%lld expected=%lld CHECK=%s\n",
           joined_sum, shared_sum, expected, ok ? "PASS" : "FAIL");
    return ok ? EXIT_SUCCESS : EXIT_FAILURE;
}

预期结果与区间

task=0 range=[0,250) partial=31375
task=1 range=[250,501) partial=94376
task=2 range=[501,752) partial=157377
task=3 range=[752,1003) partial=220378
joined_sum=503506 shared_sum=503506 expected=503506 CHECK=PASS

主线程按任务编号join并打印，所以这段打印顺序固定；worker实际执行和完成顺序仍可不同。区间边界N*t/THREADS与N*(t+1)/THREADS采用整数除法，即使N不能被线程数整除也能覆盖全部元素。

最容易写错的三个地址

写法	含义
pthread_create(&threads[t], NULL, worker, &tasks[t])	第一个地址是线程标识输出位置；最后一个地址是参数对象位置。
pthread_join(threads[t], &result)	第一个传标识本身；第二个让join把worker返回的指针写入result，因此是void**。
return &task->partial	指向仍然存活的main对象，安全；return &local指向将被销毁的线程栈局部变量，不可用。

错误写法与修复

/* 错误示意：大家拿到同一个循环变量的地址 */
for (int i=0; i<4; ++i)
    pthread_create(&threads[i], NULL, worker, &i);

/* 正确思路：每线程独立参数槽位，且活到join之后 */
for (int i=0; i<4; ++i)
    pthread_create(&threads[i], NULL, worker, &tasks[i]);

“多个线程都有自己的arg变量”不代表指向的对象互不共享。上面的错误示意中，arg指针各有一份，但都指向同一个i，主线程还会修改i。

错误码先分接口家族

int rc = pthread_create(&tid, NULL, worker, arg);
if (rc != 0) fprintf(stderr, "%s\n", strerror(rc));

/* semaphore家族通常是-1 + errno */
if (sem_post(ready) == -1) perror("sem_post");

多数pthread函数直接返回错误号，不能仅用perror解释它们。pthread_self返回标识，pthread_equal返回真假，pthread_exit不返回；barrier_wait还有一个特殊的成功返回值，见函数手册。

平台验证：本机Apple clang17.0.0，-std=c11 -Wall -Wextra -Werror -pthread编译并运行通过。示例未使用macOS缺少的pthread_barrier_*，信号量完整程序使用sem_open。

来源：Apple pthread_create说明；POSIX对pthread_create、pthread_join及线程返回值的定义。课件第14/16/17页入口函数指针误写为(void)，正确入口接收(void*)，与第18页一致。