POSIX 线程¶

#include <pthread.h>

int pthread_create(
    pthread_t       *thread,    /* 输出：新线程的 ID */
    pthread_attr_t  *attr,      /* 线程属性，NULL 使用默认值 */
    void *(*start)(void *),     /* 线程入口函数 */
    void            *arg        /* 传给入口函数的参数 */
);
/* 成功返回 0，失败返回正值错误码（不是 -1） */

typedef struct {
    int   conn_fd;
    char *client_ip;
} ThreadArgs;

void *handle_client(void *arg) {
    ThreadArgs *targs = (ThreadArgs *)arg;
    /* 使用 targs->conn_fd 和 targs->client_ip */
    free(targs);   /* 堆上分配的参数由线程自己释放 */
    return NULL;
}

/* 调用方 */
ThreadArgs *targs = malloc(sizeof(ThreadArgs));
targs->conn_fd   = accept_fd;
targs->client_ip = strdup(ip_str);
pthread_create(&tid, NULL, handle_client, targs);

#include <pthread.h>

void *worker(void *arg) {
    /* ... 处理工作 ... */
    pthread_exit((void *)42);   /* 等价于 return (void *)42 */
}

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

/* 方式一：创建后分离 */
pthread_t tid;
pthread_create(&tid, NULL, worker, NULL);
pthread_detach(tid);

/* 方式二：线程自行分离（在入口函数内） */
void *worker(void *arg) {
    pthread_detach(pthread_self());
    /* ... */
    return NULL;
}

/* 方式三：创建时通过属性指定分离状态 */
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&tid, &attr, worker, NULL);
pthread_attr_destroy(&attr);

int counter = 0;  /* 全局变量 */

void *increment(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;   /* 实际上是三条指令：读 → 加 → 写 */
    }
    return NULL;
}

#include <pthread.h>

pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;

void *safe_increment(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&counter_mutex);   /* 加锁：其他线程在此阻塞 */
        counter++;                             /* 临界区 */
        pthread_mutex_unlock(&counter_mutex); /* 解锁：释放给等待的线程 */
    }
    return NULL;
}

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t *m = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(m, NULL);   /* NULL 表示使用默认属性 */

/* 使用完后必须销毁 */
pthread_mutex_destroy(m);
free(m);

int ret = pthread_mutex_trylock(&m);
if (ret == 0) {
    /* 成功获取锁，执行临界区 */
    pthread_mutex_unlock(&m);
} else if (ret == EBUSY) {
    /* 锁已被占用，执行备用逻辑 */
}

pthread_mutex_t rec_mutex;
pthread_mutexattr_t attr;

pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&rec_mutex, &attr);
pthread_mutexattr_destroy(&attr);

while (queue_empty()) {
    /* 空转等待，100% 占满一个 CPU 核心 */
}

pthread_mutex_t q_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  q_cond  = PTHREAD_COND_INITIALIZER;
int             q_size  = 0;

/* 消费者线程：等待队列非空 */
void *consumer(void *arg) {
    pthread_mutex_lock(&q_mutex);

    /* 必须用 while，不能用 if（防止虚假唤醒） */
    while (q_size == 0) {
        pthread_cond_wait(&q_cond, &q_mutex);
        /* wait 原子地：1.释放 mutex，2.挂起线程
           被唤醒后：3.重新加锁 mutex，4.返回       */
    }

    /* 此时持有锁，且条件成立（q_size > 0） */
    consume_item();
    q_size--;

    pthread_mutex_unlock(&q_mutex);
    return NULL;
}

/* 生产者线程：添加数据后通知消费者 */
void *producer(void *arg) {
    pthread_mutex_lock(&q_mutex);
    produce_item();
    q_size++;
    pthread_cond_signal(&q_cond);    /* 唤醒一个等待者 */
    pthread_mutex_unlock(&q_mutex);
    return NULL;
}

#include <pthread.h>

pthread_rwlock_t config_lock = PTHREAD_RWLOCK_INITIALIZER;

/* 读操作：多个线程可并发 */
void read_config(void) {
    pthread_rwlock_rdlock(&config_lock);
    /* ... 读取配置，安全并发 ... */
    pthread_rwlock_unlock(&config_lock);
}

/* 写操作：独占访问 */
void update_config(void) {
    pthread_rwlock_wrlock(&config_lock);
    /* ... 修改配置，排他访问 ... */
    pthread_rwlock_unlock(&config_lock);
}

#include <pthread.h>

/* 全局键，所有线程共享这个键，但通过它访问各自的数据 */
static pthread_key_t tls_key;

/* 数据析构函数：线程退出时自动调用，释放资源 */
static void cleanup(void *value) {
    free(value);
}

/* 初始化键（通常在 main 或 pthread_once 中调用一次） */
pthread_key_create(&tls_key, cleanup);

/* 在线程中存取私有数据 */
void *worker(void *arg) {
    /* 为本线程分配私有数据 */
    int *my_value = malloc(sizeof(int));
    *my_value = 42;
    pthread_setspecific(tls_key, my_value);

    /* 后续在任意函数中读取 */
    int *val = pthread_getspecific(tls_key);

    return NULL;
}

/* 程序退出前销毁键 */
pthread_key_delete(tls_key);

/* 每个线程有自己的 counter 副本，初始值都是 0 */
__thread int counter = 0;         /* GCC 扩展 */
_Thread_local int counter = 0;    /* C11 标准写法 */

void *worker(void *arg) {
    counter++;   /* 修改的是本线程的副本，不影响其他线程 */
    return NULL;
}

pthread_cancel(target_tid);   /* 请求取消，不会立即生效 */

/* 禁用/启用取消 */
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);  /* 屏蔽取消请求 */
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,  NULL);  /* 恢复响应（默认）*/

/* 设置取消类型 */
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,  NULL);  /* 延迟到取消点（默认）*/
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);  /* 立即取消（危险！）*/

void unlock_on_cancel(void *arg) {
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}

void *worker(void *arg) {
    pthread_mutex_lock(&m);

    /* 注册清理处理器：线程被取消时自动调用 */
    pthread_cleanup_push(unlock_on_cancel, &m);

    /* ... 执行可能被取消的操作（包含取消点）... */

    /* 1 表示执行清理后 pop；0 表示只 pop 不执行 */
    pthread_cleanup_pop(1);

    return NULL;
}

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
pthread_mutex_init(&m, &attr);
/* 同一线程重复加锁会返回 EDEADLK 而非死锁 */