C++ std::thread lambda
时间: 2023-11-09 12:01:09 浏览: 204
C++11 引入了 std::thread 类,可以用于创建新线程。使用 lambda 表达式可以方便地在线程中执行函数。
例如,以下代码创建了一个新线程并执行 lambda 表达式:
```
#include <iostream>
#include <thread>
int main() {
std::thread t([](){
std::cout << "Hello from thread!" << std::endl;
});
t.join();
return 0;
}
```
输出:
```
Hello from thread!
```
在 lambda 表达式中,我们可以访问外部变量,但需要注意线程安全问题。
相关问题
c++ std::thread 类
C++ 标准库中的 `std::thread` 类是用于处理线程的工具。它是 `<thread>` 头文件的一部分,允许程序员创建、启动、管理和同步线程。以下是一些关键点:
1. **创建线程**:你可以通过构造函数创建一个新的线程,并传递一个函数指针作为线程的目标,或者是一个lambda表达式。
```cpp
std::thread thread_function(target_function, arg1, arg2);
```
2. **启动线程**:一旦线程被创建,你可以调用 `start()` 函数开始它的执行。
```cpp
thread_function.start();
```
3. **暂停和继续**:如果你想暂时停止线程,可以调用 `join()` 函数等待线程结束;如果你想恢复其执行,线程可能不具备这样的功能,通常需要外部信号或者使用互斥量等同步机制。
4. **异常处理**:线程内部抛出的异常不会影响主线程,你需要使用 `catch(thread::hardware_breakpoint)` 或者捕获异常的方式处理线程内的错误。
5. **共享数据**:使用 `std::mutex`、`std::condition_variable` 或其他同步原语,可以在多个线程间安全地共享数据。
```cpp
std::mutex mutex;
void* shared_data;
// 线程A
{
std::lock_guard<std::mutex> lock(mutex);
// 修改 shared_data
}
// 线程B
{
std::unique_lock<std::mutex> lock(mutex);
// 读取 shared_data
}
```
c++std::thread
### C++ 中 `std::thread` 的使用方法
#### 创建线程
为了创建一个新的线程,可以实例化一个 `std::thread` 对象并传递给其构造函数想要在线程中运行的任务。这个任务通常是一个函数或 lambda 表达式。
```cpp
#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()` 可以等待线程完成工作后再继续执行后续代码:
```cpp
t.join();
// 主线程在此处暂停直到子线程结束
```
#### 分离线程 (`detach`)
分离线程意味着让新启动的线程独立于主线程之外运行,而不需要显式的同步机制:
```cpp
t.detach();
// 子线程将继续异步执行直至完成自己的生命周期
```
#### 获取线程ID
可以通过 `get_id()` 函数获得当前线程的身份标识符:
```cpp
auto id = t.get_id();
std::cout << "Thread ID is " << id << std::endl;
```
#### 检测是否可加入
要判断某个线程对象关联的实际操作系统级别的线程是否存在且未被回收,则可以用 `joinable()` 成员函数来进行测试:
```cpp
if (t.joinable()) {
// 如果该条件成立则表示存在有效的工作线程可供连接
}
```
#### Lambda表达式作为参数传入
也可以利用lambda表达式向线程传递额外的数据,在下面的例子中展示了如何捕获局部变量以及外部作用域内的数据结构:
```cpp
#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` 来实现跨线程间的安全通信与协调:
```cpp
#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();
}
```
阅读全文
相关推荐














