Linux多线程编程实战：从基础到高级应用

1. Linux多线程编程概述

在Linux系统开发中，多线程编程是提升程序性能的核心技术之一。与多进程相比，线程作为轻量级的执行单元，共享相同的内存空间，使得数据交换和通信更加高效。我在实际项目中发现，合理使用多线程技术可以使CPU密集型应用的性能提升3-5倍。

现代Linux系统主要采用POSIX线程标准（pthread），这套API提供了完整的线程创建、同步和销毁机制。值得注意的是，Linux内核实际上将所有线程都视为轻量级进程（LWP）来实现，这与Windows等系统的线程实现有本质区别。

2. 线程创建与管理

2.1 pthread基础操作

创建线程使用pthread_create函数，其原型如下：

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

一个完整的创建示例：

c复制#include <pthread.h>
#include <stdio.h>

void* thread_func(void* arg) {
    printf("Thread ID: %lu\n", (unsigned long)pthread_self());
    return NULL;
}

int main() {
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, thread_func, NULL);
    if(ret != 0) {
        perror("pthread_create failed");
        return 1;
    }
    
    pthread_join(tid, NULL);  // 等待线程结束
    return 0;
}

注意：线程函数必须返回void并接受void参数，这是POSIX标准的要求。

2.2 线程属性设置

通过pthread_attr_t结构体可以设置线程的多种属性：

c复制pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  // 设置为分离状态
pthread_attr_setstacksize(&attr, 1024*1024);  // 设置栈大小为1MB

实际项目中我发现，设置合理的栈大小特别重要。默认栈大小（通常2-8MB）对于简单任务可能过大，而对于递归算法可能又太小。

3. 线程同步机制

3.1 互斥锁（Mutex）

最基本的同步原语，用于保护临界区：

c复制pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* bank_transfer(void* arg) {
    pthread_mutex_lock(&mutex);
    // 临界区操作
    pthread_mutex_unlock(&mutex);
    return NULL;
}

常见问题：

1. 忘记解锁导致死锁
2. 锁粒度太大影响性能
3. 递归锁与非递归锁混用

3.2 条件变量（Condition Variable）

用于线程间的事件通知：

c复制pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* consumer(void* arg) {
    pthread_mutex_lock(&mutex);
    while(!condition) {
        pthread_cond_wait(&cond, &mutex);
    }
    // 处理条件满足的情况
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void* producer(void* arg) {
    pthread_mutex_lock(&mutex);
    condition = 1;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

重要提示：条件变量必须与互斥锁配合使用，且判断条件必须使用while循环而非if语句，避免虚假唤醒问题。

4. 高级线程技术

4.1 线程局部存储（TLS）

每个线程拥有独立的变量副本：

c复制__thread int counter = 0;  // GCC扩展语法

void* thread_func(void* arg) {
    counter++;  // 每个线程有自己的counter副本
    printf("Counter: %d\n", counter);
    return NULL;
}

4.2 线程取消

安全地终止线程：

c复制void cleanup_handler(void* arg) {
    printf("Cleaning up resources\n");
}

void* thread_func(void* arg) {
    pthread_cleanup_push(cleanup_handler, NULL);
    
    // 设置为可取消状态
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
    
    while(1) {
        pthread_testcancel();  // 取消点
        // 工作代码
    }
    
    pthread_cleanup_pop(0);
    return NULL;
}

5. 性能优化与调试

5.1 线程池实现

避免频繁创建销毁线程的开销：

c复制typedef struct {
    pthread_t *threads;
    int thread_count;
    task_queue_t queue;
} thread_pool_t;

void* worker_thread(void* arg) {
    thread_pool_t* pool = (thread_pool_t*)arg;
    while(1) {
        task_t task = get_task(&pool->queue);
        task.function(task.arg);
    }
    return NULL;
}

5.2 常见问题排查

1. 死锁检测：

   • 使用gdb的thread apply all bt命令查看所有线程堆栈
   • 使用pstack <pid>查看进程的线程状态

2. 性能分析：

   bash复制perf stat -e context-switches ./your_program
   valgrind --tool=helgrind ./your_program
   

3. 内存问题：

   • 线程栈溢出：使用ulimit -s调整栈大小
   • 共享数据竞争：使用-fsanitize=thread编译选项

6. 现代多线程开发

6.1 C++11线程库

虽然本文主要讨论POSIX线程，但在C++项目中更推荐使用标准库：

cpp复制#include <thread>
#include <mutex>

std::mutex mtx;

void thread_func() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区
}

int main() {
    std::thread t1(thread_func);
    std::thread t2(thread_func);
    t1.join();
    t2.join();
    return 0;
}

6.2 协程与异步IO

对于IO密集型应用，考虑更轻量的并发模型：

c复制// 使用libuv等库实现事件循环
uv_loop_t *loop = uv_default_loop();
uv_fs_t req;
uv_fs_open(loop, &req, "file.txt", O_RDONLY, 0, on_open);
uv_run(loop, UV_RUN_DEFAULT);

在多核CPU上，我通常采用"线程池+事件循环"的混合模式，既利用多核优势，又避免过多线程上下文切换的开销。