Linux C++配置多线程注意什么

在 Linux 下使用 C++ 进行多线程编程时，需要注意很多系统层面和语言层面的问题。下面从基础配置、线程模型、同步、性能、常见坑几个方面系统说明。

一、编译与基本配置

1. 编译必须链接 pthread

Linux 下 C++ 多线程通常基于 POSIX 线程（pthread）：

g++ main.cpp -pthread -std=c++17

-pthread：同时定义宏并链接线程库（推荐，比 -lpthread 更安全）
使用 std::thread 也必须加

2. 推荐使用 C++11 及以上线程库

#include <thread>
#include <mutex>
#include <condition_variable>

避免直接使用裸 pthread（除非有底层需求）。

二、线程创建与管理

1. 线程生命周期

std::thread t(func);
t.join();   // 必须 join 或 detach

⚠️ 注意：

不 join 也不 detach → 程序崩溃
detach 后线程资源不可控，慎用

2. 避免拷贝不可拷贝对象

std::thread t([&](){ ... });  // 引用捕获要小心

⚠️ 如果线程比局部变量活得久，引用会悬空。

三、数据共享与同步（重点）

1. 共享数据必须加锁

std::mutex mtx;
int cnt = 0;

void func() {
    std::lock_guard<std::mutex> lock(mtx);
    cnt++;
}

常见同步工具：

std::mutex
std::recursive_mutex
std::shared_mutex（C++17，读写锁）
std::condition_variable

2. 死锁防范

死锁常见原因：

多锁顺序不一致
忘记解锁（异常路径）
递归加锁普通 mutex

✅ 解决方案：

使用 std::lock_guard / std::unique_lock
固定加锁顺序
使用 std::scoped_lock（C++17）

std::scoped_lock lock(m1, m2);

3. 条件变量注意虚假唤醒

std::condition_variable cv;
std::mutex mtx;
bool ready = false;

cv.wait(lock, []{ return ready; });

❌ 错误写法：

cv.wait(lock);

四、Linux 特有注意事项

1. 线程数量限制

查看系统限制：

ulimit -u
cat /proc/sys/kernel/threads-max

⚠️ 线程不是越多越好：

通常 1–2 × CPU 核心数（CPU 密集）
IO 密集可适当增加

2. CPU 亲和性（可选）

#include <pthread.h>
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(0, &cpuset);
pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

用于：

降低 cache miss
实时性要求

3. 信号（signal）与线程

Linux 信号是进程级的：

多线程中：
- 用一个专用线程处理信号
- 其他线程用 pthread_sigmask 屏蔽

❌ 不要在每个线程里 signal()

五、性能与调试

1. 避免伪共享（False Sharing）

struct alignas(64) Counter {
    int val;
};

适用于高频计数器。

2. 使用线程池而非频繁建线程

频繁 std::thread 创建/销毁开销大。

✅ 推荐：

std::async（简单任务）
自写线程池
第三方库（boost::asio / folly）

3. 调试工具

gdb + info threads
htop
perf
helgrind / tsan（检测数据竞争）

g++ -fsanitize=thread

六、常见坑总结（非常重要）

❌ 共享变量不加锁
❌ 线程引用局部变量
❌ join/detach 遗漏
❌ 死锁
❌ 条件变量不防虚假唤醒
❌ 线程数过多
❌ signal 使用不当

七、推荐实践模板

#include <thread>
#include <mutex>

std::mutex mtx;

void worker(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    // 安全操作共享数据
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    t1.join();
    t2.join();
}

如果你愿意，我可以：

给你一个 Linux 线程池示例
讲 std::async vs std::thread
或针对 高并发服务器 场景给建议