当前位置：首页 > news >正文

学懂C++（二十四）：高级教程——C++ 多线程编程中 std::thread 的深入详解

news 来源：原创 2024/9/20 17:23:02

在 C++11 中，std::thread 提供了对于多线程编程的强大支持。本节内容将详细探讨 std::thread 的使用，包括构造函数、成员函数、参数传递的注意事项等，同时结合示例进行深入讲解。

一、头文件

要使用 std::thread，需要包含以下头文件：

#include <iostream> // 用于输入输出操作
#include <thread>   // 用于线程支持
#include <mutex>    // 用于线程间的同步（可选）
#include <vector>   // 用于容器支持（可选）
#include <memory>   // 用于智能指针（可选）

具体来说：

#include <iostream>：用于输入输出操作，通常用于打印信息。
#include <thread>：这是使用 std::thread 所必需的头文件，提供了多线程支持。
#include <mutex>：用于定义互斥量（std::mutex）等同步机制，以控制线程之间的访问。
#include <vector>：常用于存储线程或者其他动态数组的容器，虽然不是 std::thread 必需的，但在多线程编程中经常使用。
#include <memory>：提供智能指针（如 std::shared_ptr、std::unique_ptr），在多线程环境中管理动态内存时非常有用。

二、`std::thread` 构造函数

std::thread 的构造函数用于创建一个新线程并执行指定的可调用对象（如函数、Lambda 表达式等）。

示例 1：基本的线程创建

#include <iostream>
#include <thread>void threadFunction() {std::cout << "Thread is running!" << std::endl;
}int main() {std::thread t(threadFunction); // 创建线程并执行 threadFunctionif (t.joinable()) { // 检查线程是否可以被加入t.join(); // 等待线程完成}std::cout << "Thread has finished." << std::endl;return 0;
}

输出结果

Thread is running!
Thread has finished.

三、其他成员函数

1. `join()`

用于等待线程完成。

2. `joinable()`

检查线程是否可以被加入。

3. `detach()`

将线程与主线程分离，允许线程在后台运行。

示例 2：使用 detach()

#include <iostream>
#include <thread>
#include <chrono>void threadFunction() {std::this_thread::sleep_for(std::chrono::seconds(1));std::cout << "Detached thread is running!" << std::endl;
}int main() {std::thread t(threadFunction);t.detach(); // 使线程与主线程分离std::this_thread::sleep_for(std::chrono::seconds(2)); // 等待一段时间std::cout << "Main thread is finishing." << std::endl;return 0;
}

输出结果

Detached thread is running!
Main thread is finishing.

四、传递临时参数作为线程对象的注意事项

4.1 解决办法

在创建线程时传递临时参数时，需要注意临时对象的生命周期问题。

示例 3：传递临时参数错误示例

#include <iostream>
#include <thread>void printMessage(std::string msg) {std::cout << msg << std::endl;
}int main() {std::thread t(printMessage, "Hello from thread!"); // 传递临时参数t.join(); // 等待线程完成return 0;
}

输出结果

Hello from thread!

4.2 原因分析

虽然上述程序在此情况下运行正常，但如果将其改为使用临时对象的引用，则会出现问题：

示例 4：传递临时参数的引用错误示例

#include <iostream>
#include <thread>void printMessage(const std::string& msg) {std::cout << msg << std::endl;
}int main() {std::string temp = "Hello from thread!";std::thread t(printMessage, std::move(temp)); // 使用 std::move 传递t.join(); // 等待线程完成// std::cout << temp << std::endl; // 这里会导致未定义行为return 0;
}

4.3 总结

在创建线程时，避免直接传递临时对象的引用。可以使用 std::shared_ptr 或 std::unique_ptr 来确保对象的生命周期。

五、传递类对象、智能指针作为线程参数

5.1 修改子线程中的对象，不会影响主线程中的对象

如果向线程传递对象的拷贝，当在子线程中修改对象时，主线程中的对象不会受到影响。

示例 5：传递类对象

#include <iostream>
#include <thread>class Counter {
public:void increment() {for (int i = 0; i < 5; ++i) {++value;std::this_thread::sleep_for(std::chrono::milliseconds(100));}}int getValue() const {return value;}private:int value = 0;
};int main() {Counter counter;std::thread t(&Counter::increment, counter); // 传递对象的拷贝t.join(); // 等待线程完成std::cout << "Main thread counter value: " << counter.getValue() << std::endl; // 值为 0return 0;
}

输出结果

Main thread counter value: 0

5.2 传递智能指针

使用智能指针可以在多个线程间共享同一对象。

示例 6：使用 std::shared_ptr

#include <iostream>
#include <thread>
#include <memory>class Counter {
public:void increment() {for (int i = 0; i < 5; ++i) {++value;std::this_thread::sleep_for(std::chrono::milliseconds(100));}}int getValue() const {return value;}private:int value = 0;
};int main() {auto counter = std::make_shared<Counter>(); // 创建共享指针std::thread t(&Counter::increment, counter); // 传递智能指针t.join(); // 等待线程完成std::cout << "Main thread counter value: " << counter->getValue() << std::endl; // 值为 5return 0;
}

输出结果

Main thread counter value: 5

六、`std::this_thread` 命名空间中相关辅助函数介绍

std::this_thread 命名空间提供了一些与当前线程相关的辅助函数。

1. `sleep_for()`

使当前线程睡眠指定的时间。

示例 7：使用 sleep_for()

#include <iostream>
#include <thread>void threadFunction() {std::cout << "Thread will sleep for 2 seconds..." << std::endl;std::this_thread::sleep_for(std::chrono::seconds(2)); // 使线程睡眠std::cout << "Thread awakens!" << std::endl;
}int main() {std::thread t(threadFunction);t.join(); // 等待线程完成return 0;
}

输出结果

Thread will sleep for 2 seconds...
Thread awakens!

2. `sleep_until()`

使当前线程睡眠直到指定的时间点。

示例 8：使用 sleep_until()

#include <iostream>
#include <thread>
#include <chrono>void threadFunction() {auto wakeUpTime = std::chrono::steady_clock::now() + std::chrono::seconds(2);std::cout << "Thread will sleep until a specific time..." << std::endl;std::this_thread::sleep_until(wakeUpTime); // 睡眠直到指定时间std::cout << "Thread awakens!" << std::endl;
}int main() {std::thread t(threadFunction);t.join(); // 等待线程完成return 0;
}

输出结果

Thread will sleep until a specific time...
Thread awakens!

3. `get_id()`

获取当前线程的 ID。

示例 9：使用 get_id()

#include <iostream>
#include <thread>void printThreadId() {std::cout << "Thread ID: " << std::this_thread::get_id() << std::endl;
}int main() {std::thread t(printThreadId);t.join(); // 等待线程完成return 0;
}

输出结果