Linux 多线程编程核心原理与实践

注意：主线程 PID 等于 LWP，新线程的 PID 可能不同。LWP (Light Weight Process) 是内核调度的基本单位。

线程等待与清理

已退出的线程若未被回收，其资源无法释放，造成内存泄漏。使用 pthread_join 阻塞等待线程结束并获取返回值。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
using namespace std;

void *threadRoutine(void *args) {
    int cnt = 5;
    while(cnt > 0) {
        cout << "new thread" << endl;
        sleep(2);
        cnt--;
    }
    return (void*)100;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, nullptr);
    
    void *retval;
    pthread_join(tid, &retval); // 等待结束并获取返回值
    cout << "retval: " << (long long int)retval << endl;
    return 0;
}

此外，pthread_self 可获取当前线程 ID。若不想关心返回值，可使用 pthread_detach 将线程设为分离状态，退出时自动释放资源。

线程私有存储

默认情况下全局变量对所有线程可见。若需线程局部存储（TLS），可使用 __thread 关键字修饰内置类型。

__thread int g_val = 100; // 线程局部存储

互斥与同步

临界区与数据竞争

多线程并发修改共享数据（如 tickets--）会导致数据不一致。这是因为 -- 操作并非原子，涉及读、改、写三步汇编指令。解决之道是互斥锁，保证同一时刻只有一个线程访问临界资源。

抢票示例（无锁）：

// 简化的抢票逻辑
while(tickets > 0) {
    usleep(1000);
    printf("who=%s, get ticket: %d\n", name, tickets);
    tickets--; // 存在竞态条件
}

加锁修复：

#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void *getTicket(void *args) {
    while(true) {
        pthread_mutex_lock(&lock); // 申请锁
        if(tickets > 0) {
            printf("who=%s, get ticket: %d\n", name, tickets);
            tickets--;
        } else {
            pthread_mutex_unlock(&lock);
            break;
        }
        pthread_mutex_unlock(&lock); // 释放锁
    }
    return nullptr;
}

死锁预防

死锁需同时满足四个条件：互斥、请求与保持、不剥夺、循环等待。避免策略包括破坏任一条件、统一加锁顺序、一次性分配资源等。

条件变量

条件变量用于线程间同步，必须配合互斥锁使用。pthread_cond_wait 会在等待时自动释放锁，唤醒后重新获取锁。

pthread_cond_wait(&cond, &mutex);

常用操作：

• pthread_cond_signal: 唤醒一个等待线程。
• pthread_cond_broadcast: 唤醒所有等待线程。

生产者 - 消费者模型

这是经典的同步问题，涉及生产者和消费者的协调。使用阻塞队列结合条件变量可实现解耦。

BlockQueue 实现要点：

• 队列满时生产者等待。
• 队列空时消费者等待。
• 使用互斥锁保护队列操作。

template <class T>
class BlockQueue {
    // ... 省略部分实现细节
    void push(const T &in) {
        pthread_mutex_lock(&mutex_);
        while(q_.size() == maxcap_) {
            pthread_cond_wait(&p_cond_, &mutex_);
        }
        q_.push(in);
        pthread_cond_signal(&c_cond_);
        pthread_mutex_unlock(&mutex_);
    }
    // ... pop 方法类似
};

信号量

信号量本质是计数器，用于描述资源数目。基于环形队列的实现利用信号量管理读写位置索引。

sem_t cdata_sem_; // 消费者关注的数据资源
sem_t pspace_sem_; // 生产者关注的空间资源

void Push(const T &in) {
    sem_wait(&pspace_sem_); // 等待有空位
    // 写入数据
    sem_post(&cdata_sem_);  // 通知有数据
}

线程池技术

线程池通过复用固定数量的线程来减少创建销毁开销，以空间换时间。

核心逻辑：

1. 维护任务队列。
2. 线程池启动若干工作线程。
3. 工作线程从队列取任务执行，队列为空时进入等待状态。
4. 新任务提交时唤醒工作线程。

class ThreadPool {
    // ... 内部维护 mutex, cond, queue
    static void *HandlerTask(void *args) {
        while(true) {
            Lock();
            while(IsQueueEmpty()) ThreadSleep();
            T t = Pop();
            Unlock();
            t(); // 执行任务
        }
    }
};

自旋锁与读写锁

自旋锁适用于临界区极短的场景，避免上下文切换开销。读写锁（RWLock）则区分读者和写者，允许多个读者同时访问，但写者独占。

掌握这些机制，能帮助我们在 Linux 环境下构建高效、稳定的并发系统。实际开发中，建议优先使用高级抽象（如 C++11 std::thread, std::mutex），底层 pthread 更多用于理解原理或特定嵌入式场景。