Linux 多线程编程：Pthreads 核心函数与资源管理详解

#include <pthread.h>

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

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

void pthread_exit(void *retval);

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

// 线程任务：接收一个整数，计算其平方，并将结果通过堆内存返回
void* square_calculator(void* arg) {
    int input_value = *(int*)arg;
    printf("子线程: 接收到值 %d，开始计算...\n", input_value);
    sleep(1);

    // 正确做法：在堆上分配内存来存储返回值
    int* result_ptr = malloc(sizeof(int));
    *result_ptr = input_value * input_value;

    printf("子线程: 计算完成，结果为 %d。线程即将退出。\n", *result_ptr);
    pthread_exit((void*)result_ptr);
}

int main(void) {
    pthread_t tid;
    void* thread_return_value;
    int number = 12;

    // 1. 创建线程
    pthread_create(&tid, NULL, square_calculator, &number);

    printf("主线程: 已创建计算线程，正在等待其完成...\n");

    // 2. 等待并回收线程，同时接收返回值
    pthread_join(tid, &thread_return_value);

    int final_result = *(int*)thread_return_value;
    printf("主线程: 已回收子线程，获取到其返回值为: %d\n", final_result);

    // 3. 释放子线程分配的堆内存（运行不到，因为线程已经自行退出）
    free(thread_return_value);

    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <limits.h> // for PTHREAD_STACK_MIN

int main(void) {
    pthread_t tid;
    pthread_attr_t attr; // 1. 定义
    size_t desired_stack_size = 32 * 1024; // 期望设置 32KB
    size_t actual_stack_size;

    pthread_attr_init(&attr); // 2. 初始化

    // 3. 设置自定义的栈大小
    pthread_attr_setstacksize(&attr, desired_stack_size);

    // (可选) 验证设置是否成功
    pthread_attr_getstacksize(&attr, &actual_stack_size);
    printf("设置的线程栈大小为: %zu 字节\n", actual_stack_size);

    // 4. 使用自定义属性创建线程
    pthread_create(&tid, &attr, some_task_function, NULL); // some_task_function 未定义，仅为演示

    pthread_attr_destroy(&attr); // 5. 销毁

    pthread_join(tid, NULL);
    return 0;
}

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

void* background_task(void* arg) {
    printf("分离线程: 开始执行，2秒后自动退出并由系统回收资源。\n");
    sleep(2);
    printf("分离线程: 执行完毕。\n");
    return NULL;
}

int main(void) {
    pthread_t tid;
    pthread_attr_t attr; // 1. 定义

    pthread_attr_init(&attr); // 2. 初始化
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 3. 设置为分离状态

    // 4. 使用该属性创建线程
    pthread_create(&tid, &attr, background_task, NULL);

    pthread_attr_destroy(&attr); // 5. 销毁

    printf("主线程: 分离线程已创建，无需join。\n");
    // 必须保证主线程存活足够长时间，否则整个进程退出，分离线程也会被终止
    sleep(3);

    printf("主线程退出。\n");
    return 0;
}

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

void* another_background_task(void* arg) {
    printf("子线程: 我被创建了，将自我分离。\n");
    pthread_detach(pthread_self()); // 自我分离
    sleep(2);
    printf("子线程: 任务完成，自动退出。\n");
    return NULL;
}

int main(void) {
    pthread_t tid;

    // 正常创建一个可连接的线程
    pthread_create(&tid, NULL, another_background_task, NULL);

    // 主线程无需再对其进行任何操作
    printf("主线程: 子线程已创建，它会自我分离。主线程等待3秒。\n");
    sleep(3);

    printf("主线程退出。\n");
    return 0;
}

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

// 清理函数：在线程被取消时调用，负责释放资源
void cleanup_handler(void *arg) {
    char *buffer = (char *)arg;
    printf("\n[清理函数]: 线程被取消，释放内存: '%s'\n", buffer);
    free(buffer);
}

void* worker_thread(void* arg) {
    char* dynamic_buffer = malloc(100);
    sprintf(dynamic_buffer, "这是一块需要被释放的动态内存");

    // 注册清理函数，当线程被取消时，`cleanup_handler` 会被调用
    pthread_cleanup_push(cleanup_handler, dynamic_buffer);

    printf("子线程: 已获取资源，进入无限循环...\n");
    int i = 0;
    while (1) {
        printf("%d ", i++);
        fflush(stdout);
        sleep(1); // sleep() 是一个取消点
    }

    // `push` 和 `pop` 必须成对出现。参数0表示正常结束时不执行清理函数。
    pthread_cleanup_pop(0);
    return NULL;
}

int main(void) {
    pthread_t tid;
    pthread_create(&tid, NULL, worker_thread, NULL);

    sleep(4); // 让子线程运行一会儿

    printf("\n主线程: 发送取消请求给子线程！\n");
    pthread_cancel(tid);

    // 等待被取消的线程完成清理并完全终止
    pthread_join(tid, NULL);

    printf("主线程: 已确认子线程被取消并回收。\n");
    return 0;
}

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

// 共享的银行账户结构体
typedef struct {
    int balance;              // 账户余额
    pthread_mutex_t lock;     // 保护余额的互斥锁
} BankAccount;

// 存款操作 (临界区)
void deposit(BankAccount *acc, int amount) {
    pthread_mutex_lock(&acc->lock); // 加锁

    // --- 临界区开始 ---
    printf("尝试存款 %d, 当前余额: %d\n", amount, acc->balance);
    int old_balance = acc->balance;
    usleep(10000); // 模拟处理耗时，增加竞态条件发生概率
    acc->balance = old_balance + amount;
    printf("存款成功, 最新余额: %d\n", acc->balance);
    // --- 临界区结束 ---

    pthread_mutex_unlock(&acc->lock); // 解锁
}

// 取款操作 (临界区)
void withdraw(BankAccount *acc, int amount) {
    pthread_mutex_lock(&acc->lock); // 加锁

    // --- 临界区开始 ---
    printf("尝试取款 %d, 当前余额: %d\n", amount, acc->balance);
    if (acc->balance >= amount) {
        int old_balance = acc->balance;
        usleep(10000); // 模拟处理耗时
        acc->balance = old_balance - amount;
        printf("取款成功, 最新余额: %d\n", acc->balance);
    } else {
        printf("余额不足, 取款失败!\n");
    }
    // --- 临界区结束 ---

    pthread_mutex_unlock(&acc->lock); // 解锁
}

// 模拟客户操作的线程函数
void* customer_action(void* arg) {
    BankAccount *acc = (BankAccount*)arg;
    for (int i = 0; i < 5; ++i) {
        if (rand() % 2) {
            deposit(acc, 100);
        } else {
            withdraw(acc, 100);
        }
        usleep(100000); // 随机延时
    }
    return NULL;
}

int main() {
    BankAccount my_account;
    my_account.balance = 1000;
    pthread_mutex_init(&my_account.lock, NULL); // 初始化互斥锁

    pthread_t tids[5];
    for (int i = 0; i < 5; ++i) {
        pthread_create(&tids[i], NULL, customer_action, &my_account);
    }

    for (int i = 0; i < 5; ++i) {
        pthread_join(tids[i], NULL);
    }

    pthread_mutex_destroy(&my_account.lock); // 销毁互斥锁
    printf("\n所有操作完成, 最终账户余额: %d\n", my_account.balance);
    return 0;
}

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

#define NUM_READERS 5
#define NUM_WRITERS 2

int shared_data = 0;
pthread_rwlock_t rw_lock;

// 读者线程
void* reader_thread(void* arg) {
    int reader_id = *(int*)arg;
    while (1) {
        pthread_rwlock_rdlock(&rw_lock); // 加读锁
        printf("读者 %d: 读取数据 = %d\n", reader_id, shared_data);
        pthread_rwlock_unlock(&rw_lock); // 解锁
        usleep(500000); // 模拟读完后的处理
    }
    return NULL;
}

// 写者线程
void* writer_thread(void* arg) {
    int writer_id = *(int*)arg;
    while (1) {
        pthread_rwlock_wrlock(&rw_lock); // 加写锁
        shared_data++;
        printf("写者 %d: 更新数据为 -> %d\n", writer_id, shared_data);
        pthread_rwlock_unlock(&rw_lock); // 解锁
        sleep(1); // 写者操作频率较低
    }
    return NULL;
}

int main() {
    pthread_rwlock_init(&rw_lock, NULL);

    pthread_t reader_tids[NUM_READERS], writer_tids[NUM_WRITERS];
    int reader_ids[NUM_READERS], writer_ids[NUM_WRITERS];

    // 创建读者线程
    for (int i = 0; i < NUM_READERS; ++i) {
        reader_ids[i] = i + 1;
        pthread_create(&reader_tids[i], NULL, reader_thread, &reader_ids[i]);
    }
    // 创建写者线程
    for (int i = 0; i < NUM_WRITERS; ++i) {
        writer_ids[i] = i + 1;
        pthread_create(&writer_tids[i], NULL, writer_thread, &writer_ids[i]);
    }

    // 主线程阻塞，防止程序退出
    pthread_join(reader_tids[0], NULL);

    pthread_rwlock_destroy(&rw_lock);
    return 0;
}

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

sem_t sem_weld;   // 允许焊接的信号量
sem_t sem_check;  // 允许检查的信号量
sem_t sem_pack;   // 允许打包的信号量

// 步骤1：焊接
void* weld_thread(void* arg) {
    while(1) {
        sem_wait(&sem_weld); // 等待焊接许可 (P操作)
        printf("======================\n(1) 焊接元器件...\n");
        sleep(1);
        sem_post(&sem_check); // 发出检查许可 (V操作)
    }
}

// 步骤2：检查
void* check_thread(void* arg) {
    while(1) {
        sem_wait(&sem_check); // 等待检查许可 (P操作)
        printf("(2) 检查元器件...\n");
        sleep(1);
        sem_post(&sem_pack); // 发出打包许可 (V操作)
    }
}

// 步骤3：打包
void* pack_thread(void* arg) {
    while(1) {
        sem_wait(&sem_pack); // 等待打包许可 (P操作)
        printf("(3) 打包并发货...\n");
        sleep(1);
        sem_post(&sem_weld); // 允许开始下一轮焊接 (V操作)
    }
}

int main() {
    // 初始时，只允许焊接(值为1)，检查和打包都不允许(值为0)
    sem_init(&sem_weld, 0, 1);
    sem_init(&sem_check, 0, 0);
    sem_init(&sem_pack, 0, 0);

    pthread_t tid_weld, tid_check, tid_pack;
    pthread_create(&tid_weld, NULL, weld_thread, NULL);
    pthread_create(&tid_check, NULL, check_thread, NULL);
    pthread_create(&tid_pack, NULL, pack_thread, NULL);

    pthread_join(tid_weld, NULL); // 主线程阻塞

    sem_destroy(&sem_weld);
    sem_destroy(&sem_check);
    sem_destroy(&sem_pack);

    return 0;
}

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

// 共享的仓库
int stock = 0;
pthread_mutex_t lock;
pthread_cond_t cond_producer;  // 条件：仓库未满，可生产
pthread_cond_t cond_consumer;  // 条件：仓库不空，可消费

// 生产者线程
void* producer_thread(void* arg) {
    while (1) {
        pthread_mutex_lock(&lock);
        while (stock >= 5) { // 条件：仓库满了
            printf("生产者: 仓库已满，等待消费...\n");
            // 等待“仓库未满”的条件，等待时自动释放锁
            pthread_cond_wait(&cond_producer, &lock);
        }
        stock++;
        printf("生产者: 生产一件产品，当前库存: %d\n", stock);
        // 通知消费者“仓库不空”了
        pthread_cond_signal(&cond_consumer);
        pthread_mutex_unlock(&lock);
        sleep(1);
    }
}

// 消费者线程
void* consumer_thread(void* arg) {
    while (1) {
        pthread_mutex_lock(&lock);
        while (stock <= 0) { // 条件：仓库空了
            printf("消费者: 仓库已空，等待生产...\n");
            // 等待“仓库不空”的条件，等待时自动释放锁
            pthread_cond_wait(&cond_consumer, &lock);
        }
        stock--;
        printf("消费者: 消费一件产品，当前库存: %d\n", stock);
        // 通知生产者“仓库未满”了
        pthread_cond_signal(&cond_producer);
        pthread_mutex_unlock(&lock);
        usleep(500000);
    }
}

int main() {
    pthread_mutex_init(&lock, NULL);
    pthread_cond_init(&cond_producer, NULL);
    pthread_cond_init(&cond_consumer, NULL);

    pthread_t pid, cid;
    pthread_create(&pid, NULL, producer_thread, NULL);
    pthread_create(&cid, NULL, consumer_thread, NULL);

    pthread_join(pid, NULL);

    pthread_mutex_destroy(&lock);
    pthread_cond_destroy(&cond_producer);
    pthread_cond_destroy(&cond_consumer);
    return 0;
}

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

// 全局的条件变量和互斥锁
pthread_cond_t cond;
pthread_mutex_t mutex;

// 工作线程函数
void* worker(void* arg) {
    int worker_id = *(int*)arg;

    while (1) {
        // 加锁以保护对条件变量的访问
        pthread_mutex_lock(&mutex);

        printf("员工 %d (TID: %lu): 正在休息，等待任务...\n", worker_id, pthread_self());
        // 等待条件变量信号，等待时会自动解锁，被唤醒后会自动加锁
        pthread_cond_wait(&cond, &mutex);

        printf("员工 %d (TID: %lu): 被唤醒，开始工作！\n", worker_id, pthread_self());
        // 模拟执行任务
        sleep(2);
        printf("员工 %d (TID: %lu): 任务完成，准备继续休息。\n\n", worker_id, pthread_self());

        // 解锁
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main(void) {
    // 1. 初始化互斥锁和条件变量
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    // 2. 创建线程池（招聘5名员工）
    const int NUM_WORKERS = 5;
    pthread_t workers[NUM_WORKERS];
    int worker_ids[NUM_WORKERS];

    for (int i = 0; i < NUM_WORKERS; i++) {
        worker_ids[i] = i + 1;
        pthread_create(&workers[i], NULL, worker, &worker_ids[i]);
    }

    // 3. 主线程（老板）派发任务
    printf("线程池已启动。按 Enter 键派发一个任务。\n");
    while (1) {
        getchar();
        printf("老板：来活了！叫醒一个员工干活！\n");
        // 发送信号，唤醒一个正在等待的线程
        pthread_cond_signal(&cond);
    }

    // (实际项目中需要有关闭线程池的逻辑)
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

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

// --- 1. 任务及任务队列定义 ---
typedef struct Task {
    void (*function)(void* arg); // 任务函数指针
    void* arg;                   // 任务函数参数
    struct Task* next;           // 指向下一个任务
} Task;

// 线程池结构体
typedef struct ThreadPool {
    Task* task_queue;          // 任务队列头指针
    pthread_mutex_t mutex;     // 互斥锁，保护任务队列
    pthread_cond_t cond;       // 条件变量，用于线程等待/通知
    pthread_t* threads;        // 工作线程ID数组
    int num_threads;           // 线程数量
} ThreadPool;

// --- 2. 任务函数 ---
void task_a(void* arg) {
    int duration = *(int*)arg;
    printf("TID %lu: 正在执行任务A，预计耗时 %d 秒...\n", pthread_self(), duration);
    sleep(duration);
    printf("TID %lu: 任务A完成。\n", pthread_self());
}

void task_b(void* arg) {
    printf("TID %lu: 正在执行任务B，打印消息: %s\n", pthread_self(), (char*)arg);
}

// --- 3. 线程池核心逻辑 ---
void* worker(void* arg) {
    ThreadPool* pool = (ThreadPool*)arg;
    while (1) {
        pthread_mutex_lock(&pool->mutex);

        // 如果任务队列为空，则等待
        while (pool->task_queue == NULL) {
            pthread_cond_wait(&pool->cond, &pool->mutex);
        }

        // 从队列头部取出一个任务
        Task* task = pool->task_queue;
        pool->task_queue = task->next;

        pthread_mutex_unlock(&pool->mutex);

        // 执行任务
        task->function(task->arg);
        free(task); // 释放任务节点
    }
    return NULL;
}

// --- 4. 主函数：创建线程池并添加任务 ---
int main(void) {
    // 初始化线程池
    ThreadPool pool;
    pool.num_threads = 5;
    pool.task_queue = NULL;
    pthread_mutex_init(&pool.mutex, NULL);
    pthread_cond_init(&pool.cond, NULL);
    pool.threads = malloc(sizeof(pthread_t) * pool.num_threads);

    // 创建工作线程
    for (int i = 0; i < pool.num_threads; i++) {
        pthread_create(&pool.threads[i], NULL, worker, &pool);
    }

    printf("线程池已创建，包含 %d 个工作线程。\n", pool.num_threads);

    // 动态添加任务
    int duration_a = 3;
    char* msg_b = "Hello, ThreadPool!";

    for (int i=0; i<10; ++i) {
        // 创建任务节点
        Task* new_task = malloc(sizeof(Task));
        if (i % 2 == 0) {
            new_task->function = task_a;
            new_task->arg = &duration_a;
        } else {
            new_task->function = task_b;
            new_task->arg = msg_b;
        }
        new_task->next = NULL;

        // 将任务添加到队列
        pthread_mutex_lock(&pool.mutex);
        Task* current = pool.task_queue;
        if (current == NULL) {
            pool.task_queue = new_task;
        } else {
            while(current->next != NULL) {
                current = current->next;
            }
            current->next = new_task;
        }
        printf("主线程：添加了一个新任务。\n");
        pthread_mutex_unlock(&pool.mutex);

        // 唤醒一个等待的线程
        pthread_cond_signal(&pool.cond);
        sleep(1);
    }

    // (实际项目中需要有关闭和销毁线程池的逻辑)
    sleep(10); // 等待任务执行
    return 0;
}

// 任务节点
typedef struct Task {
    void* (*function)(void* arg); // 任务函数指针
    void* arg;                    // 任务函数参数
    struct Task* next;            // 指向下一个任务
} Task;

// 线程池管理结构体
typedef struct ThreadPool {
    pthread_mutex_t lock;      // 互斥锁
    pthread_cond_t cond;       // 条件变量

    Task* task_list_head;      // 任务队列头

    pthread_t* tids;           // 线程ID数组
    int min_threads;           // 最小线程数
    int max_threads;           // 最大线程数
    int active_threads;        // 当前存活线程数
    int busy_threads;          // 当前正忙线程数

    bool shutdown;             // 线程池关闭标志
} ThreadPool;