Linux 多线程编程：线程栈、TLS、互斥锁与条件变量详解

通过上述代码创建多线程后，可验证每个线程是否有独立栈结构。在线程函数中定义局部变量 test，观察其地址和值。

void *threadRoutine(void *args) {
    int test = 1;
    threadData *td = (threadData *)args;
    int count = 5;
    while (count--) {
        printf("pid:%d, tid:%lx, threadname:%s, test:%d , &test:%p\n", getpid(), pthread_self(), td->threadname.c_str(), test, &test);
        test++;
        sleep(1);
    }
    return nullptr;
}

结果显示，每个线程中的局部变量 test 都是从 1 开始，且地址不同，证明每个线程拥有独立的线程栈，互不干扰。

对于全局数据，每个线程均可访问且共享同一地址。

int value = 10;
void *threadRoutine(void *args) {
    threadData *td = (threadData *)args;
    int count = 5;
    while (count--) {
        printf("pid:%d, tid:%lx, threadname:%s, value:%d , &value:%p\n", getpid(), pthread_self(), td->threadname.c_str(), value, &value);
        sleep(1);
    }
    return nullptr;
}

结果证实全局数据对每个线程共享。

线程局部存储 (TLS)

若需定义既是全局的又独属于线程的变量，可使用 __thread 关键字（GCC 提供的线程局部存储机制）。每个线程拥有独立的变量副本。

__thread int value = 10;

加 __thread 后，每个线程拥有属于自己的全局变量副本，实现全局数据区的线程隔离。

线程分离

创建新线程后，主线程调用 pthread_join 会阻塞等待线程结束。若不关心退出结果，仅需线程完成任务后自动释放资源，可使用线程分离。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <vector>

struct threadData {
    std::string threadname;
};

__thread int value = 10;

void *threadRoutine(void *args) {
    pthread_detach(pthread_self());
    threadData *td = (threadData *)args;
    int count = 5;
    while (count--) {
        printf("pid:%d, tid:%lx, threadname:%s, value:%d , &value:%p\n", getpid(), pthread_self(), td->threadname.c_str(), value, &value);
        sleep(1);
    }
    return nullptr;
}

int main() {
    std::vector<pthread_t> tids;
    for (int i = 0; i < 3; i++) {
        pthread_t tid;
        threadData *td = new threadData;
        td->threadname = "thread-" + std::to_string(i);
        pthread_create(&tid, nullptr, threadRoutine, td);
        tids.push_back(tid);
    }
    // 主线程不再 join，直接结束
    return 0;
}

线程分离后，主线程无需等待新线程。需注意主线程应在分离线程之后退出，否则程序终止会导致未完成的分离线程被强制回收。

线程的互斥

大部分情况下线程使用局部变量，但共享变量在多并发操作时可能引发问题。例如多线程抢票场景。

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <vector>

int tickets = 100;

class threadData {
public:
    threadData(int num) { threadname = "thread-" + std::to_string(num); }
public:
    std::string threadname;
};

void *getTicket(void *args) {
    threadData *td = (threadData *)args;
    while (1) {
        if (tickets > 0) {
            usleep(1000);
            printf("%s get a tickets , tickets : %d\n", td->threadname.c_str(), tickets);
            tickets--;
        } else {
            break;
        }
    }
    return nullptr;
}

int main() {
    std::vector<pthread_t> tids;
    std::vector<threadData *> thread_datas;
    for (int i = 1; i <= 3; i++) {
        pthread_t tid;
        threadData *td = new threadData(i);
        thread_datas.push_back(td);
        pthread_create(&tid, nullptr, getTicket, td);
        tids.push_back(tid);
    }
    for (int i = 0; i < 3; i++) {
        pthread_join(tids[i], nullptr);
    }
    for (auto thread : thread_datas) {
        delete thread;
    }
    return 0;
}

可能出现票数变为负数或重复抢票的情况。这是因为 tickets-- 操作非原子性，包含读取、修改、写回三步。线程切换可能导致数据不一致。

解决此问题需保证临界区代码串行执行，即加锁。

互斥锁接口

• pthread_mutex_init：初始化互斥锁。
• pthread_mutex_lock：加锁，竞争失败则阻塞。
• pthread_mutex_unlock：解锁，唤醒等待线程。
• pthread_mutex_destroy：销毁互斥锁。

加锁示例

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <vector>

int tickets = 100;

class threadData {
public:
    threadData(int num, pthread_mutex_t *mutex) : mutex_(mutex) {
        threadname = "thread-" + std::to_string(num);
    }
public:
    std::string threadname;
    pthread_mutex_t *mutex_;
};

void *getTicket(void *args) {
    threadData *td = (threadData *)args;
    while (1) {
        pthread_mutex_lock(td->mutex_);
        if (tickets > 0) {
            usleep(1000);
            printf("%s get a tickets , tickets : %d\n", td->threadname.c_str(), tickets);
            tickets--;
        } else {
            pthread_mutex_unlock(td->mutex_);
            break;
        }
        pthread_mutex_unlock(td->mutex_);
    }
    return nullptr;
}

int main() {
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, nullptr);
    std::vector<pthread_t> tids;
    std::vector<threadData *> thread_datas;
    for (int i = 1; i <= 3; i++) {
        pthread_t tid;
        threadData *td = new threadData(i, &mutex);
        thread_datas.push_back(td);
        pthread_create(&tid, nullptr, getTicket, td);
        tids.push_back(tid);
    }
    for (int i = 0; i < 3; i++) {
        pthread_join(tids[i], nullptr);
    }
    for (auto thread : thread_datas) {
        delete thread;
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

加锁后解决了数据一致性问题，但可能导致饥饿现象（某线程持续获取锁）。这类似于多人争用单一电脑的场景，持有者释放锁后若立即再次获取，其他等待者将无法获得资源。

锁的原理

CPU 指令执行具有原子性。锁的实现常利用 CPU 提供的 swap 或 exchange 指令保证原子交换。

伪代码逻辑：

1. 寄存器初始化为 0。
2. 寄存器值与内存锁值原子交换。
3. 判断寄存器值：大于 0 表示获取锁成功；否则挂起等待。

无论线程如何切换，原子交换确保同一时刻仅一个线程能获取锁。

线程的同步

线程同步要求在数据安全基础上保证访问顺序。条件变量可维护等待队列，避免忙等待。

当线程申请已被占用的锁时，调用条件变量等待接口进入挂起状态。锁释放后通知条件变量，唤醒一个等待线程重新获取锁。

条件变量接口

• pthread_cond_init：初始化条件变量。
• pthread_cond_wait：进入等待队列，挂起并释放互斥锁；唤醒后重新获取锁。
• pthread_cond_signal：唤醒一个等待线程。
• pthread_cond_broadcast：唤醒所有等待线程。
• pthread_cond_destroy：销毁条件变量。

同步示例

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <vector>

int tickets = 100;

class threadData {
public:
    threadData(int num, pthread_mutex_t *mutex, pthread_cond_t *cond) : mutex_(mutex), cond_(cond) {
        threadname = "thread-" + std::to_string(num);
    }
public:
    std::string threadname;
    pthread_mutex_t *mutex_;
    pthread_cond_t *cond_;
};

void *getTicket(void *args) {
    pthread_detach(pthread_self());
    threadData *td = (threadData *)args;
    while (1) {
        pthread_mutex_lock(td->mutex_);
        pthread_cond_wait(td->cond_, td->mutex_);
        if (tickets > 0) {
            usleep(1000);
            printf("%s get a tickets , tickets : %d\n", td->threadname.c_str(), tickets);
            tickets--;
        } else {
            pthread_mutex_unlock(td->mutex_);
            break;
        }
        pthread_mutex_unlock(td->mutex_);
    }
    return nullptr;
}

int main() {
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    pthread_mutex_init(&mutex, nullptr);
    pthread_cond_init(&cond, nullptr);
    std::vector<pthread_t> tids;
    std::vector<threadData *> thread_datas;
    for (int i = 1; i <= 3; i++) {
        pthread_t tid;
        threadData *td = new threadData(i, &mutex, &cond);
        thread_datas.push_back(td);
        pthread_create(&tid, nullptr, getTicket, td);
        tids.push_back(tid);
    }
    // 模拟信号发送
    while (tickets > 0) {
        pthread_cond_signal(&cond);
        sleep(1);
    }
    for (auto thread : thread_datas) {
        delete thread;
    }
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

通过条件变量，所有线程均有机会抢到票，避免了单线程独占资源。注意条件变量的正确用法需结合生产者 - 消费者模型进一步探讨。