C++如何创建线程｜多线程编程入门指南

最直接推荐的C++线程创建方式是使用std::thread，它通过构造函数传入函数、Lambda或函数对象来启动新线程，需调用join()或detach()管理生命周期，并用std::ref处理引用参数传递，同时借助std::mutex、std::atomic等同步机制解决数据共享问题。

在C++中创建一个线程，最直接也最推荐的方式是使用C++11标准库引入的std::thread。它提供了一个跨平台的抽象，让你能够以一种现代且类型安全的方式启动新的执行流，而无需直接与底层操作系统API打交道。本质上，你就是告诉程序：“嘿，这块代码我想让它在另一个独立的‘工人’那里运行。”

解决方案

创建std::thread非常直观，你只需要将一个可调用对象（函数、Lambda表达式、函数对象等）作为参数传递给std::thread的构造函数。这个可调用对象就是新线程要执行的任务。

#include 
#include 
#include  // 用于std::this_thread::sleep_for

// 1. 普通函数作为线程任务
void task_function(int id) {
    std::cout << "线程 " << id << ": 正在执行普通函数任务..." << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    std::cout << "线程 " << id << ": 普通函数任务完成。" << std::endl;
}

// 2. 函数对象（Functor）作为线程任务
class MyFunctor {
public:
    void operator()(std::string msg) {
        std::cout << "线程 (Functor): " << msg << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(700));
        std::cout << "线程 (Functor): 函数对象任务完成。" << std::endl;
    }
};

int main() {
    std::cout << "主线程: 启动中..." << std::endl;

    // 启动一个执行普通函数的线程
    // 注意：传递参数时，std::thread会默认拷贝参数
    std::thread t1(task_function, 1);

    // 启动一个执行Lambda表达式的线程
    // Lambda表达式可以捕获外部变量
    std::thread t2([](const std::string& name) {
        std::cout << "线程 (Lambda): " << name << " 正在执行Lambda任务..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
        std::cout << "线程 (Lambda): Lambda任务完成。" << std::endl;
    }, "Worker B");

    // 启动一个执行函数对象的线程
    MyFunctor functor_obj;
    std::thread t3(functor_obj, "Hello from Functor Thread!");

    std::cout << "主线程: 所有子线程已启动，等待它们完成..." << std::endl;

    // 等待子线程完成：join()
    // 这是一个关键步骤，确保主线程在子线程结束前不会退出
    // 如果不调用join()或detach()，程序在t1, t2, t3析构时会调用std::terminate()终止
    t1.join();
    t2.join();
    t3.join();

    std::cout << "主线程: 所有子线程已完成，主线程退出。" << std::endl;

    return 0;
}

在上面的例子中，join()方法是必不可少的。它会让当前线程（这里是主线程）阻塞，直到对应的子线程执行完毕。这就像你在等待一个朋友完成他的任务，然后你们才能一起继续。另一种选择是detach()，它会将子线程与std::thread对象分离，让子线程在后台独立运行。一旦detach()，你就不再能控制或等待这个线程了，它会自己找到终点，就像一个“自由的灵魂”。通常情况下，如果需要等待线程结果或者确保线程执行完毕，join()是更安全的选择。

std::thread到底是怎么回事？

当我们谈论std::thread时，它不仅仅是一个简单的函数调用，它代表的是一个操作系统级别的执行流。C++11标准库巧妙地封装了底层平台（比如Linux上的pthread或Windows上的CreateThread）的复杂性，提供了一个统一且易用的接口。对我来说，这简直是C++多线程编程的一大解放。以前，你可能需要根据不同的操作系统编写不同的条件编译代码，或者依赖一些第三方库，现在，std::thread让这一切变得如此简洁。

一个std::thread对象在被创建时，如果传入了有效的可调用对象，它就会立即启动一个新的执行流。这个新的执行流拥有自己的栈空间，与主线程并行运行。它的生命周期管理是一个核心问题：当一个std::thread对象被销毁时，如果它仍然关联着一个可join的（joinable）线程（即没有被join()也没有被detach()），程序会调用std::terminate()来终止，这通常意味着程序崩溃。所以，要么join()等待线程结束，要么detach()让它自生自灭，但绝不能放任不管。这就像你养了一只宠物，要么好好照顾它，要么放它自由，但不能把它晾在那里不管不顾。

传递参数给新线程有什么坑？

向新线程传递参数，听起来简单，但里面确实藏着一些让人头疼的“坑”。最常见的问题是关于参数的生命周期和传递方式。std::thread的构造函数默认会以值拷贝的方式传递参数给新线程。这对于基本类型或者可拷贝的小对象来说通常没问题，甚至可以说是安全的，因为它避免了共享数据带来的复杂性。

但如果你想通过引用传递参数，比如想让新线程修改主线程中的某个变量，直接写std::thread(my_func, my_var)是行不通的。因为std::thread会拷贝my_var本身，而不是它的引用。这时，你需要使用std::ref或std::cref（如果是不修改的常量引用），它们是std::reference_wrapper的辅助函数。

#include 
#include 
#include  // 用于std::ref

void modify_value(int& val) {
    val += 10;
    std::cout << "线程中修改后的值: " << val << std::endl;
}

int main() {
    int shared_val = 5;
    std::cout << "主线程初始值: " << shared_val << std::endl;

    // 错误示范：直接传递 shared_val，std::thread 会拷贝它，而不是引用
    // std::thread t_bad(modify_value, shared_val); // 这会编译错误，因为modify_value需要一个引用，但这里传的是右值

    // 正确做法：使用 std::ref 传递引用
    std::thread t_good(modify_value, std::ref(shared_val));

    t_good.join();
    std::cout << "主线程中最终值: " << shared_val << std::endl; // 此时 shared_val 应该已经被修改为 15
    return 0;
}

另一个大坑是指针传递。如果你的线程函数接收一个指针，而这个指针指向的内存是在主线程的栈上分配的局部变量，那么当主线程提前结束时，子线程可能还在运行，它访问的指针就成了悬空指针（dangling pointer），导致未定义行为甚至程序崩溃。这是一种经典的“数据竞态”问题，但在这里更像是“生命周期竞态”。所以，如果必须传递指针，请确保它指向的内存有足够的生命周期，比如堆上的内存，或者使用智能指针（如std::shared_ptr）来管理其生命周期。对于不可拷贝但可移动的对象（如std::unique_ptr），你则需要使用std::move来转移所有权。这些细节，真的是在实际项目中一步步踩坑才能体会到其重要性。

线程间的数据共享和同步怎么搞？

多线程编程的真正挑战，往往不在于如何创建线程，而在于如何管理线程间的数据共享和同步。想象一下，多个“工人”同时操作一个共享的工具箱，如果没有规矩，那必然会乱作一团，甚至工具都被弄坏。这就是“竞态条件”（Race Condition）的形象比喻：当两个或更多线程同时访问并修改共享数据时，最终结果会依赖于它们执行的相对时序，导致不可预测的错误。

为了解决这个问题，C++标准库提供了一系列同步原语：

1. 互斥量（std::mutex）：这是最基础的同步工具，就像一个门锁。在任何时候，只有一个线程可以获得互斥量的所有权，从而进入“临界区”（critical section）——那段访问共享代码的代码。其他线程必须等待。

   #include 
   #include 
   #include 
   #include 
   
   std::mutex mtx; // 全局或共享的互斥量
   int shared_counter = 0;
   
   void increment_counter() {
       for (int i = 0; i < 10000; ++i) {
           mtx.lock(); // 加锁
           shared_counter++;
           mtx.unlock(); // 解锁
       }
   }
   
   int main() {
       std::vector threads;
       for (int i = 0; i < 5; ++i) {
           threads.emplace_back(increment_counter);
       }
   
       for (auto& t : threads) {
           t.join();
       }
   
       std::cout << "最终计数器值: " << shared_counter << std::endl; // 期望是 5 * 10000 = 50000
       return 0;
   }

   直接使用lock()和unlock()很容易忘记解锁，导致死锁。因此，更推荐使用RAII（Resource Acquisition Is Initialization）风格的锁，如std::lock_guard或std::unique_lock。它们在构造时加锁，在析构时自动解锁，大大降低了出错的概率。

2. 条件变量（std::condition_variable）：当一个线程需要等待某个条件满足才能继续执行时，它就可以使用条件变量。例如，生产者-消费者模型中，消费者线程可能需要等待生产者线程生成了数据才能继续消费。条件变量通常与互斥量一起使用，wait()操作会原子性地释放互斥量并阻塞线程，直到被notify_one()或notify_all()唤醒。

3. 原子操作（std::atomic）：对于一些简单的操作，比如对整数进行增减，使用互斥量可能显得有些“重”。std::atomic提供了一种无锁的线程安全机制，可以对基本类型进行原子操作。这意味着这些操作是不可中断的，要么完全执行，要么不执行，不会出现中间状态。这对于性能敏感的计数器等场景非常有用。

这些工具的使用，需要你对程序的并发逻辑有清晰的理解。一旦引入多线程，程序的调试难度会几何级数增长，因为错误不再是线性的、可预测的。所以，我的经验是，能不用共享数据就尽量避免，如果非用不可，那就老老实实地用好这些同步原语，并且尽可能地缩小临界区，减少锁的持有时间。