C++11中std::thread的使用

C++11 引入了 std::thread，它是用于创建和管理线程的标准库类。以下是详细的讲解，包括如何使用 std::thread 进行线程创建、管理和参数传递等操作。

1. 包含必要的头文件

在使用 std::thread 前，需要包含 <thread> 头文件：

#include <thread>

2. 创建和启动线程

可以通过传递一个可调用对象（函数、lambda 表达式或函数对象）给 std::thread 的构造函数来创建和启动线程。

示例：使用函数

#include <iostream>
#include <thread>

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::thread t(printMessage, "Hello from the thread!");
    t.join(); // 等待线程完成
    return 0;
}

示例：使用 lambda 表达式

#include <iostream>
#include <thread>

int main() {
    std::thread t([]() {
        std::cout << "Hello from the lambda thread!" << std::endl;
    });
    t.join(); // 等待线程完成
    return 0;
}

3. 等待线程完成

使用 join 方法可以阻塞主线程，直到被 join 的线程执行完毕。

t.join();

4. 分离线程

使用 detach 方法可以将线程分离，分离后的线程在后台独立运行，直到执行完毕。

t.detach();

5. 传递参数给线程

可以通过构造函数传递参数给线程函数。

示例：传递多个参数

#include <iostream>
#include <thread>

void printValues(int a, double b) {
    std::cout << "a = " << a << ", b = " << b << std::endl;
}

int main() {
    std::thread t(printValues, 10, 3.14);
    t.join();
    return 0;
}

6. 使用 `std::ref` 传递引用参数

默认情况下，std::thread 会复制传递给它的参数。如果需要传递引用，可以使用 std::ref。

示例：传递引用参数

#include <iostream>
#include <thread>
#include <functional> // std::ref

void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    std::string message = "Hello from the reference thread!";
    std::thread t(printMessage, std::ref(message));
    t.join();
    return 0;
}

7. 检查线程是否可联结（joinable）

可以使用 joinable 方法检查线程是否可以 join。如果一个线程已经被 join 或 detach，那么它将不再是可联结的。

if (t.joinable()) {
    t.join();
}

8. 线程的异常处理

可以在线程函数中使用异常处理机制（如 try-catch 块）来捕获和处理异常。

示例：在线程中处理异常

#include <iostream>
#include <thread>

void threadFunction() {
    try {
        throw std::runtime_error("An error occurred");
    } catch (const std::exception& e) {
        std::cerr << "Exception caught in thread: " << e.what() << std::endl;
    }
}

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

9. 线程的硬件并发性

可以使用 std::thread::hardware_concurrency 来获取系统支持的并发线程数。

unsigned int n = std::thread::hardware_concurrency();
std::cout << "Number of concurrent threads supported: " << n << std::endl;

10. 使用 `std::async` 和 `std::future` 管理异步任务

除了 std::thread，C++11 还引入了 std::async 和 std::future 来简化异步任务的管理。

示例：使用 `std::async`

#include <iostream>
#include <future>

int compute() {
    return 42;
}

int main() {
    std::future<int> result = std::async(compute);
    std::cout << "Result from async: " << result.get() << std::endl;
    return 0;
}

通过以上步骤和示例，可以较全面地了解和使用 C++11 中的 std::thread 来进行多线程编程。

IOT-Power