现代C++特性 并发编程：线程管理库 ＜thread＞（C++11）

发布于：2025-09-01 ⋅ 阅读:(20) ⋅ 点赞:(0)

文章目录

C++11 起引入 <thread> 头文件，提供对多线程的原生支持。

创建线程

//默认构造函，构造一个线程对象，在这个线程中不执行任何处理动作
thread() noexcept;

//移动构造函数，将 other 的线程所有权转移给新的 thread 对象。之后 other 不再表示执行线程。
thread( thread&& other ) noexcept;

// 创建线程对象，并在该线程中执行函数 f 中的业务逻辑，args 是要传递给函数 f 的参数。任务函数 f 的可选类型有很多，普通函数，类成员函数，匿名函数，仿函数
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );

要创建线程，首先需要一个可调用函数或函数对象，作为线程的入口点。

std::thread t(Function&& f, Args&&... args);

std::thread t1(func);
std::thread t2 = std::move(t1);  // OK
// std::thread t3 = t1;          // 错误！禁止拷贝
  • function_name 是线程入口点的函数或可调用对象，支持的 Function 类型包括：
    • 普通函数 void func(); t(func);
    • Lambda 表达式 t([](){ std::cout << "Hello"; });
    • 函数对象（仿函数） struct Task { void operator()(); }; t(Task{});
    • 类成员函数 t(&MyClass::method, &obj);
    • 绑定函数（std::bind） t(std::bind(&func, arg));
  • args... 是传递给函数的参数

创建线程后，我们可以使用 t.join()等待线程完成，或者使用 t.detach()分离线程，让它在后台运行。

例如，下面的代码创建了一个线程，输出一条消息：

#include <thread>
#inlcude <iostream>

void print_message() {
    std::cout << "Hello,world!" << std::endl;
}

int main() {
    std::thread t(print_message);
    t.join();
    
    return 0;
}

operator=

线程中的资源是不能被复制的，因此通过 = 操作符进行赋值操作最终并不会得到两个完全相同的对象。

// move (1)	
thread& operator= (thread&& other) noexcept;
// copy [deleted] (2)	
thread& operator= (const other&) = delete;

通过以上 = 操作符的重载声明可以得知：

  • 如果 other 是一个右值，会进行资源所有权的转移
  • 如果 other 不是右值，禁止拷贝，该函数被显示删除（=delete），不可用

线程 ID 与身份识别：get_id()

应用程序启动之后默认只有一个线程，这个线程一般称之为主线程或父线程，通过线程类创建出的线程一般称之为子线程，每个被创建出的线程实例都对应一个线程 ID，这个 ID 是唯一的，可以通过这个 ID 来区分和识别各个已经存在的线程实例，这个获取线程 ID 的函数叫做 get_id()，函数原型如下：

std::thread::id get_id() const noexcept;

示例程序：

#include <iostream>
#include <thread>
#include <chrono>
using namespace std;

void func(int num, string str)
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "子线程: i = " << i << "num: " 
             << num << ", str: " << str << endl;
    }
}

void func1()
{
    for (int i = 0; i < 10; ++i)
    {
        cout << "子线程: i = " << i << endl;
    }
}

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
}

在上面的示例程序中有一个 bug，在主线程中依次创建出两个子线程，打印两个子线程的线程 ID，最后主线程执行完毕就退出了（主线程就是执行 main () 函数的那个线程）。默认情况下，主线程销毁时会将与其关联的两个子线程也一并销毁，但是这时有可能子线程中的任务还没有执行完毕，最后也就得不到我们想要的结果了。

线程管理：join() 与 detach()

每个 std::thread 对象在销毁前必须调用 join() 或 detach()，否则程序会调用 std::terminate() 终止。

方法 作用 是否阻塞 适用场景
join() 主动等待线程结束，回收资源 ✅ 阻塞调用者 需要等待结果或确保线程完成
detach() 分离线程，后台运行，自动回收 ❌ 不阻塞 不关心线程何时结束，如日志写入、心跳检测

join()

join() 字面意思是连接一个线程，意味着主动地等待线程的终止（线程阻塞）。在某个线程中通过子线程对象调用 join() 函数，调用这个函数的线程被阻塞，但是子线程对象中的任务函数会继续执行，当任务执行完毕之后 join() 会清理当前子线程中的相关资源然后返回，同时，调用该函数的线程解除阻塞继续向下执行。

再次强调，我们一定要搞清楚这个函数阻塞的是哪一个线程，函数在哪个线程中被执行，那么函数就阻塞哪个线程。该函数的函数原型如下：

void join();

有了这样一个线程阻塞函数之后，就可以解决在上面测试程序中的 bug 了，如果要阻塞主线程的执行，只需要在主线程中通过子线程对象调用这个方法即可，当调用这个方法的子线程对象中的任务函数执行完毕之后，主线程的阻塞也就随之解除了。 修改之后的示例代码如下：

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
    t.join();
    t1.join();
}

当主线程运行到第八行 t.join();，根据子线程对象 t 的任务函数 func() 的执行情况，主线程会做如下处理：

  • 如果任务函数 func() 还没执行完毕，主线程阻塞，直到任务执行完毕，主线程解除阻塞，继续向下运行
  • 如果任务函数 func() 已经执行完毕，主线程不会阻塞，继续向下运行

同样，第 9 行的代码亦如此。

detach()

detach() 函数的作用是进行线程分离，分离主线程和创建出的子线程。在线程分离之后，主线程退出也会一并销毁创建出的所有子线程，在主线程退出之前，它可以脱离主线程继续独立的运行，任务执行完毕之后，这个子线程会自动释放自己占用的系统资源。该函数函数原型如下：

void detach();

线程分离函数没有参数也没有返回值，只需要在线程成功之后，通过线程对象调用该函数即可，继续将上面的测试程序修改一下：

int main()
{
    cout << "主线程的线程ID: " << this_thread::get_id() << endl;
    thread t(func, 520, "i love you");
    thread t1(func1);
    cout << "线程t 的线程ID: " << t.get_id() << endl;
    cout << "线程t1的线程ID: " << t1.get_id() << endl;
    t.detach();
    t1.detach();
    // 让主线程休眠, 等待子线程执行完毕
    this_thread::sleep_for(chrono::seconds(5));
}

注意事项：线程分离函数 detach () 不会阻塞线程，子线程和主线程分离之后，在主线程中就不能再对这个子线程做任何控制了，比如：通过 join () 阻塞主线程等待子线程中的任务执行完毕，或者调用 get_id () 获取子线程的线程 ID。有利就有弊，鱼和熊掌不可兼得，建议使用 join ()。

线程状态查询：joinable()

joinable() 函数用于判断主线程和子线程是否处理关联（连接）状态，一般情况下，二者之间的关系处于关联状态，该函数返回一个布尔类型：

  • 返回值为 true：主线程和子线程之间有关联（连接）关系，线程可以被join()或detach()
  • 返回值为 false：主线程和子线程之间没有关联（连接）关系，如果我们试图对一个不可join的线程调用join()或detach()，则会抛出一个std::system_error异常。
bool joinable() const noexcept;

#include <iostream>
#include <thread>
void foo() {
    std::cout << "Thread started" << std::endl;
}
int main() {
    std::thread t(foo);
    if (t.joinable()) {
        t.join();
    }
    std::cout << "Thread joined" << std::endl;
    return 0;
}

静态函数：硬件并发数

thread 线程类还提供了一个静态方法，用于获取当前计算机的 CPU 核心数，根据这个结果在程序中创建出数量相等的线程，每个线程独自占有一个CPU核心，这些线程就不用分时复用CPU时间片，此时程序的并发效率是最高的。

static unsigned hardware_concurrency() noexcept;

#include <iostream>
#include <thread>
using namespace std;

int main()
{
    int num = thread::hardware_concurrency();
    cout << "CPU number: " << num << endl;
}

用途：合理设置线程池大小，避免过度创建线程。

命名空间 std::this_thread

提供对当前线程的操作。

函数 说明
get_id() 获取当前线程 ID
sleep_for(duration) 睡眠指定时间
sleep_until(time_point) 睡眠到指定时间点
yield() 提示调度器让出 CPU 时间片 
std::this_thread::sleep_for(std::chrono::seconds(1));
std::this_thread::sleep_until(std::chrono::system_clock::now() + 2s);

常见错误

  • 忘记等待线程完成或分离线程：如果我们创建了一个线程，但没有等待它完成或分离它，那么在主线程结束时，可能会导致未定义行为。 解决方案：

    • RAII 封装（如 std::jthread C++20）
    • 智能指针管理线程生命周期
    • 使用作用域守卫（std::unique_ptr<std::thread, Deleter>）

  • 访问共享数据时没有同步：如果我们在多个线程中访问共享数据，但没有使用同步机制，那么可能会导致数据竞争、死锁等问题。

  • 异常传递问题：如果在线程中发生了异常，但没有处理它，那么可能会导致程序崩溃。因此，我们应该在线程中使用try-catch块来捕获异常，并在适当的地方处理它。

    std::thread t([]{
    try {
        // 业务逻辑
    } catch (...) {
        // 处理异常
    }
});

  • 传递临时变量问题：

    #include <iostream>
#include <thread>
void foo(int& x) {
    x += 1;
}
int main() {
    std::thread t(foo, 1); // 传递临时变量
    t.join();
    return 0;
}

    临时变量使用使用之后立即释放不占内存，取不到引用。

    解决方案是将变量复制到一个持久的对象中，然后将该对象传递给线程。例如，我们可以将1复制到一个int类型的变量中，然后将该变量的引用传递给线程。

    #include <iostream>
#include <thread>
void foo(int& x) {
    x += 1;
}
int main() {
    int x = 1; // 将变量复制到一个持久的对象中
    std::thread t(foo, std::ref(x)); // 将变量的引用传递给线程
    t.join();
    return 0;
}

  • 传递指针或引用指向局部变量(或指向已释放内存)的问题：

    #include <iostream>
#include <thread>

std::thread t;
void foo(int& x) {
    x += 1;
}
void test() {
    int a = 1;		//局部变量，只在test内有效
    t = std::thread(foo, std::ref(a));
    return;  		//a在此处已经被释放
}
int main() {
    test();
    t.join();
    return 0;
}

    类成员函数作为入口函数，类对象被提前释放同理。

    可以使用 std::shared_ptr 来管理类对象的生命周期，确保在线程执行期间对象不会被销毁。具体来说，可以在创建线程之前，将类对象的指针封装在一个 std::shared_ptr 对象中，并将其作为参数传递给线程。这样，在线程执行期间，即使类对象的所有者释放了其所有权，std::shared_ptr 仍然会保持对象的生命周期，直到线程结束。

    #include <iostream>
#include <thread>
#include <memory>

class MyClass {
public:
    void func() {
        std::cout << "Thread " << std::this_thread::get_id() 
        << " started" << std::endl;
        // do some work
        std::cout << "Thread " << std::this_thread::get_id() 
        << " finished" << std::endl;
    }
};

int main() {
    std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();
    std::thread t(&MyClass::func, obj);
    t.join();
    return 0;
}

  • 入口函数为类的私有成员函数

    #include <iostream>
#include <thread>

class MyClass {
private:
	friend void myThreadFunc(MyClass* obj);	//将 myThreadFunc 定义为 MyClass 类的友元函数
	void privateFunc() {
		std::cout << "Thread " 
		<< std::this_thread::get_id() << " privateFunc" << std::endl;
	}
};

void myThreadFunc(MyClass* obj) {
	obj->privateFunc();
}

int main() {
	MyClass obj;
	std::thread thread_1(myThreadFunc, &obj);	//在函数中调用 privateFunc 函数
	thread_1.join();
	return 0;
}

完整使用示例

#include <iostream>
#include <thread>
#include <chrono>

void task(int id) {
    for (int i = 0; i < 3; ++i) {
        std::cout << "Thread " << id << ": " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
}

int main() {
    std::cout << "Main thread ID: " << std::this_thread::get_id() << std::endl;

    std::thread t1(task, 1);
    std::thread t2(task, 2);

    std::cout << "t1 ID: " << t1.get_id() << std::endl;
    std::cout << "t2 ID: " << t2.get_id() << std::endl;

    if (t1.joinable()) t1.join();
    if (t2.joinable()) t2.join();

    std::cout << "All threads finished." << std::endl;
    return 0;
}

总结：std::thread 是 C++ 多线程的基础，掌握其构造、生命周期管理、参数传递和常见陷阱，是编写安全并发程序的关键。建议结合 std::mutex、std::future 等工具一起使用，构建完整的并发模型。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布