c++ std::thread用法

C++中的std::thread是用于创建和管理线程的类。下面是std::thread的用法示例[^2]：

#include <iostream>
#include <thread>

// 线程函数
void myFunc(int n) {
    std::cout << "myFunc n = " << n << std::endl;
}

int main() {
    int num = 10;

    // 创建线程并传递参数
    std::thread t(myFunc, num);

    // 等待线程执行完毕
    t.join();

    return 0;
}

在上面的示例中，我们首先包含了<iostream>和<thread>头文件。然后定义了一个名为myFunc的函数，该函数接受一个整数参数n，并在控制台输出该参数的值。在主函数中，我们创建了一个std::thread对象t，并将myFunc函数和num作为参数传递给它。然后我们使用t.join()等待线程执行完毕。

相关问题

c++std::thread

### C++ 中 `std::thread` 的使用方法

#### 创建线程
为了创建一个新的线程，可以实例化一个 `std::thread` 对象并传递给其构造函数想要在线程中运行的任务。这个任务通常是一个函数或 lambda 表达式。

#include <iostream>
#include <thread>

void backgroundTask() {
    std::cout << "Running on a separate thread." << std::endl;
}

int main() {
    std::thread t(backgroundTask);
}

当不再需要线程时，应该调用 `join()` 或者 `detach()` 方法来释放资源[^1]。

#### 加入线程 (`join`)
通过调用 `join()` 可以等待线程完成工作后再继续执行后续代码：

t.join();
// 主线程在此处暂停直到子线程结束

#### 分离线程 (`detach`)
分离线程意味着让新启动的线程独立于主线程之外运行，而不需要显式的同步机制：

t.detach();
// 子线程将继续异步执行直至完成自己的生命周期

#### 获取线程ID
可以通过 `get_id()` 函数获得当前线程的身份标识符：

auto id = t.get_id();
std::cout << "Thread ID is " << id << std::endl;

#### 检测是否可加入
要判断某个线程对象关联的实际操作系统级别的线程是否存在且未被回收，则可以用 `joinable()` 成员函数来进行测试：

if (t.joinable()) {
    // 如果该条件成立则表示存在有效的工作线程可供连接
}

#### Lambda表达式作为参数传入
也可以利用lambda表达式向线程传递额外的数据，在下面的例子中展示了如何捕获局部变量以及外部作用域内的数据结构：

#include <iostream>
#include <string>
#include <thread>

int main(){
    int local_state=0;
    auto func=[&local_state]() mutable -> void{
        ++local_state;
        std::cout<<"Local state:"<<local_state<<'\n';
    };
    
    std::thread(func).join();  
}

#### 处理返回值
对于那些有返回值得情况，我们可以借助 `std::promise`, `std::future` 和 `std::packaged_task` 来实现跨线程间的安全通信与协调:

#include <iostream>
#include <memory>
#include <future>
#include <utility>
#include <functional>
using namespace std;

double divide(double a,double b){
    if(b==0) throw runtime_error("Division by zero!");
    return a/b;
}

int main(){
    packaged_task<double(double,double)> task(divide);
    future<double> result=task.get_future();

    thread td(move(task),2.0,4.0);

    try{
        cout<<result.get()<<endl;//阻塞在这里直到得到结果
    }
    catch(exception const&e){
        cerr<<e.what()<<endl;
    }

    td.join();
}

c++ std::thread 创建线程

C++标准库中的`std::thread`是一个用于创建和管理线程的类。它提供了一种简单而有效的方式来创建和管理线程，并在不同的线程上执行任务。

要使用`std::thread`创建线程，需要按照以下步骤进行操作：

1. 包含头文件：在代码中包含`<thread>`头文件。
2. 定义线程函数：将要执行的代码封装在一个函数中，该函数将作为新线程要执行的代码。
3. 创建线程对象：使用`std::thread`构造函数创建一个线程对象，并将要执行的函数作为参数传递给它。
4. 启动线程：调用线程对象的`start()`成员函数来启动新线程。这将使线程函数在新的线程上执行。

下面是一个简单的示例代码，展示了如何使用`std::thread`创建线程：

#include <iostream>
#include <thread>

// 线程函数
void myThreadFunction() {
    std::cout << "Hello from new thread!" << std::endl;
}

int main() {
    // 创建线程对象并启动新线程
    std::thread myThread(myThreadFunction);
    myThread.join(); // 等待新线程完成执行
    return 0;
}

在上面的示例中，我们定义了一个名为`myThreadFunction`的函数，它将在新的线程上执行。然后，我们使用`std::thread`构造函数创建了一个名为`myThread`的线程对象，并将`myThreadFunction`函数作为参数传递给它。最后，我们调用`myThread.join()`来等待新线程完成执行。

需要注意的是，一旦线程对象被创建并启动后，就不能再被重新启动或销毁。因此，在使用`std::thread`时，需要确保正确管理线程的生命周期，并在适当的时候调用`join()`或`detach()`方法来控制线程的执行和终止。