C++ 多线程库 <thread>
C++ 多线程库
C++11 引入了多线程支持，通过
线程是程序执行的最小单元，是操作系统能够进行运算调度的最小单位。在多线程程序中，多个线程可以并行执行，提高程序的执行效率。
C++
std::thread：表示一个线程，可以创建、启动、等待和销毁线程。
std::this_thread：提供了一些静态成员函数，用于操作当前线程。
std::thread::id：线程的唯一标识符。
创建线程
要创建一个线程，你需要实例化 std::thread 类，并传递一个可调用对象（函数、lambda 表达式或对象的成员函数）作为参数。
实例
#include
#include
void print_id(int id) {
std::cout << “ID: “ << id << “, Thread ID: “ << std::this_thread::get_id() << std::endl;
}
int main() {
std::thread t1(print_id, 1);
std::thread t2(print_id, 2);
}
启动线程
创建 std::thread 对象后，线程会立即开始执行，你可以调用 join() 方法来等待线程完成。
t1.join();
t2.join();
等待线程完成
join() 方法会阻塞当前线程，直到被调用的线程完成执行。
销毁线程
当线程执行完毕后，你可以使用 detach() 方法来分离线程，或者让 std::thread 对象超出作用域自动销毁。
t1.detach(); // 线程将继续运行，但无法再被 join 或 detach
实例：使用
下面是一个使用
实例
#include
#include
int sum = 0;
void add(int a, int b) {
sum += a + b;
}
int main() {
int a = 5;
int b = 10;
std::thread t1(add, a, b);
std::thread t2(add, a, b);
t1.join();
t2.join();
std::cout << “Sum: “ << sum << std::endl; // 输出结果：Sum: 30
}
输出结果为：
Sum: 30
以下实例我们将创建两个线程，每个线程都会执行一个简单的函数，该函数打印一个消息并休眠一段时间：
实例
#include
#include
#include
// 简单的函数，在线程中执行
void print_message(const std::string& message, int delay) {
std::this_thread::sleep_for(std::chrono::milliseconds(delay));
std::cout << message << std::endl;
}
int main() {
// 创建两个线程，执行 print_message 函数
std::thread t1(print_message, “Hello from thread 1”, 1000);
std::thread t2(print_message, “Hello from thread 2”, 500);
// 等待线程 t1 完成
if (t1.joinable()) {
t1.join();
}
// 等待线程 t2 完成
if (t2.joinable()) {
t2.join();
}
std::cout << “Main thread finished.” << std::endl;
return 0;
}
输出结果为：
Hello from thread 2
Hello from thread 1
Main thread finished.
注意事项
线程安全：在多线程环境中，共享资源需要同步访问，以避免数据竞争。
线程生命周期：确保在线程执行完毕后正确地处理线程对象，避免资源泄露。
类和函数
主要组件
std::threadstd::mutexstd::lock_guardstd::unique_lockstd::condition_variablestd::future 和 std::promisestd::async
std::thread
std::thread 类用于创建和管理线程。
实例
#include
#include
void print_hello() {
std::cout << “Hello from thread!” << std::endl;
}
int main() {
std::thread t(print_hello);
t.join(); // 等待线程 t 结束
return 0;
}
重要方法
join(): 等待线程结束。detach(): 将线程置于后台运行，不再等待线程结束。joinable(): 检查线程是否可被 join 或 detach。
std::mutex
std::mutex 类用于同步对共享资源的访问。
实例
#include
#include
#include
std::mutex mtx; // 创建一个全局 mutex 对象
int shared_resource = 0; // 共享资源
// 线程函数
void increment() {
std::lock_guardstd::mutex lock(mtx); // 上锁，保证线程安全
++shared_resource;
std::cout << “Incremented shared_resource to “ << shared_resource << std::endl;
// lock 在 lock_guard 离开作用域时自动释放
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join(); // 等待线程 t1 完成
t2.join(); // 等待线程 t2 完成
std::cout << “Final value of shared_resource: “ << shared_resource << std::endl;
return 0;
}
std::lock_guard
std::lock_guard 是一个 RAII 风格的锁管理器，用于自动管理锁的生命周期。
实例
#include
#include
#include
std::mutex mtx;
void print_thread_id(int id) {
std::lock_guardstd::mutex lock(mtx);
std::cout << “Thread ID: “ << id << std::endl;
}
int main() {
std::thread t1(print_thread_id, 1);
std::thread t2(print_thread_id, 2);
t1.join();
t2.join();
return 0;
}
std::unique_lock
std::unique_lock 提供了比 std::lock_guard 更灵活的锁管理。
实例
#include
#include
#include
std::mutex mtx;
void print_thread_id(int id) {
std::unique_lockstd::mutex lock(mtx);
std::cout << “Thread ID: “ << id << std::endl;
lock.unlock(); // 可以手动解锁
// … 其他操作
}
int main() {
std::thread t1(print_thread_id, 1);
std::thread t2(print_thread_id, 2);
t1.join();
t2.join();
return 0;
}
std::condition_variable
std::condition_variable 用于线程间的等待和通知。
实例
#include
#include
#include
#include
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
std::unique_lockstd::mutex lock(mtx);
cv.wait(lock, []{ return ready; });
std::cout << “Thread ID: “ << id << std::endl;
}
void set_ready() {
std::unique_lockstd::mutex lock(mtx);
ready = true;
cv.notify_all();
}
int main() {
std::thread t1(print_id, 1);
std::thread t2(print_id, 2);
std::this_thread::sleep_for(std::chrono::seconds(1));
set_ready();
t1.join();
t2.join();
return 0;
}
std::future 和 std::promise
std::future 和 std::promise 用于线程间的结果传递。
实例
#include
#include
#include
void calculate_square(std::promise
p.set_value(x * x);
}
int main() {
std::promise
std::future
std::thread t(calculate_square, std::move(p), 5);
std::cout << “Square: “ << f.get() << std::endl;
t.join();
return 0;
}
std::async
std::async 用于启动异步任务，并返回一个 std::future。
实例
#include
#include
int calculate_square(int x) {
return x * x;
}
int main() {
std::future
std::cout << “Square: “ << result.get() << std::endl;
return 0;
}
C++ 的