Linux 线程控制详解：从 pthread 到 C++11

线程默认是阻塞等待的。关于异常处理，单个线程若发生严重异常，整个进程通常会崩溃，因此一般不单独捕获线程异常。此外，不能使用 exit() 直接退出整个进程，应使用 return 或 pthread_exit() 仅退出当前线程。

资源共享与竞争

多个线程共享同一进程的全局变量和函数。这意味着它们可以访问相同的数据空间，但也容易引发数据冲突。

int g_val = 100;

void* threadRoutine(void* args) {
    const char* str = (const char*)args;
    int cnt = 5;
    while (cnt--) {
        printf("%s pid: %d, g_val: %d, &g_val: 0x%p\n", 
               str, getpid(), g_val, &g_val);
        sleep(1);
        g_val++; // 存在竞态条件
    }
    return (void*)100;
}

int main() {
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoutine, (void*)"thread 1");
    
    int cnt = 5;
    while (cnt--) {
        printf("main thread %d, g_val: %d, &g_val: 0x%p, create a new thread: %p\n",
               getpid(), g_val, &g_val, tid);
        sleep(1);
        g_val++;
    }
    sleep(2);
    void* set;
    pthread_join(tid, &set);
    cout << "new thread quit success" << static_cast<long long>(set) << endl;
    return 0;
}

可以通过 ps -aL 命令查看线程信息。可以看到两个线程拥有相同的进程 PID，但 LWP（Light Weight Process）不同。在内核视角下，LWP 就是线程。线程 ID 分为两种：内核视角的 LWP 和用户视角的 pthread_t。

用户级线程（由线程库控制）加上内核 LWP 才构成完整的 Linux 线程模型。目前主流实现是 1:1 模型，即一个用户线程对应一个内核调度实体。

高级用法：对象传递

线程的参数和返回值不仅可以是基本类型，还可以传递自定义对象。这在实际开发中非常常见，比如将任务范围封装成类。

class Request {
public:
    Request(int begin, int end, const string& threadname)
        : _begin(begin), _end(end), _threadname(threadname) {}
public:
    int _begin;
    int _end;
    string _threadname;
};

class Response {
public:
    Response(int result, int exitcode)
        : _result(result), _exitcode(exitcode) {}
public:
    int _result;      // 计算结果
    int _exitcode;    // 状态码
};

void* sumRoutine(void* args) {
    Request* rq = static_cast<Request*>(args);
    Response* rsp = new Response(0, 0);
    
    if (rq->_begin > rq->_end) {
        rsp->_exitcode = -1;
    } else {
        for (int i = rq->_begin; i <= rq->_end; i++) {
            rsp->_result += i;
        }
    }
    delete rq;
    return rsp;
}

int main() {
    pthread_t tid;
    Request* rq = new Request(1, 100, "thread 1");
    
    pthread_create(&tid, nullptr, sumRoutine, rq);
    
    void* set;
    pthread_join(tid, &set);
    
    Response* rsp = static_cast<Response*>(set);
    cout << "rsp -> _result: " << rsp->_result 
         << " rsp ->_exitcode: " << rsp->_exitcode << endl;
    delete rsp;
    return 0;
}

现代方案：C++11 多线程

C++11 标准引入了 <thread> 头文件，对多线程进行了更好的封装，语法更简洁，推荐使用。

#include <thread>
#include <iostream>
#include <unistd.h>

void threadRun() {
    while (true) {
        cout << "I am a new thread for C++" << endl;
        sleep(1);
    }
}

int main() {
    thread t1(threadRun);
    t1.join();
    return 0;
}

相比 pthread，C++11 的 std::thread 自动管理生命周期，支持 RAII 机制，且能更好地与 C++ 对象交互。