Lambda 捕获此函数和长时间运行的函数

Lambda capturing this and long-running function

本文关键字：函数 长时间 运行 Lambda      更新时间：2023-10-16

我有一个需要很长时间才能运行的函数，但幸运的是它是异步运行的。 我想获取此函数调用的结果并将其设置为类实例的私有变量。 似乎很容易：

// Exists in some other library.
void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A {
public:
void Do() {
auto lambda = [this](int val) {
// Some processing...
var_ = val;
};
LongRunningAsync(lambda);
}
private:
var_;
};
int main() {
A* a = new A;
a->Do();
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}

问题是在注释之前将以下行添加到main中：

delete a;

现在，当LongRunningAsync调用回调时，它将尝试修改已删除实例的成员变量(即 UB(。

有没有办法挽救这种方法？我最近了解了以下解决方案：

void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A : public std::enable_shared_from_this<A> {
public:
void Do() {
std::weak_ptr<A> weak = shared_from_this();
auto lambda = [weak](int val) {
auto shared = weak.lock();
if (!shared) return;
// Some processing...
shared->var_ = val;
};
LongRunningAsync(lambda);
}
private:
var_;
};
int main() {
auto a = std::make_shared<A>();
a->Do();
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}

但它需要将所有A变量更改为shared_ptr。 有没有一种侵入性较小的方法来完成这项工作？

一种可能的解决方案是将您需要的状态封装到shared_ptr成员变量中，然后按值将其捕获到异步运行的闭包中。

如下所示

class A : public std::enable_shared_from_this<A> {
public:
void Do() {
auto lambda = [member_shared_state](int val) {
member_shared_state->var_ = val;
};
LongRunningAsync(lambda);
}
....
};

这是一个基于 Curious 方法的解决方案，但这并不强制我将所有指向A对象的指针更改为shared_ptr：

// Exists in some other library.
void LongRunningAsync(std::function<void(int)> callback) {
sleep(10);
callback(5);
}
class A {
public:
A() : var_(std::make_shared<int>()) {}
void Do() {
std::weak_ptr<int> weak = var_;
auto lambda = [weak](int val) {
auto shared = weak.lock();
if (!shared) {
return;
}
// Some processing...
*shared = val;
};
LongRunningAsync(lambda);
}
private:
std::shared_ptr<int> var_;
};
int main() {
A* a = new A;
a->Do();
delete a;
// Wait for LongRunningAsync to finish.
sleep(20);
return 0;
}
相关文章：