1

我已经通过了一个承诺作为对线程的引用。之后，promise 通过 std::move 移动到向量中。这会在执行软件时导致分段错误。

我认为在移动承诺后线程中的引用永远不会更新？如何将承诺传递给线程，以便之后可以移动它？请参阅我的问题的以下代码示例。

#include <iostream>
#include <thread>
#include <vector>
#include <future>


class Test {        
    public:
    std::thread t;
    std::promise<int> p;
    Test(std::thread&& rt, std::promise<int>&& rp) : t(std::move(rt)), p(std::move(rp)) {}
};

int main()
{
    std::vector<Test> tests;

    {
        auto p = std::promise<int>();
        std::thread t ([&p]{
            std::cout << 1;
            p.set_value(1);
        });
        tests.push_back(Test(std::move(t), std::move(p)));
    }  

    for(Test& mytest : tests)
    {
        mytest.t.join();
    }

}
4

2 回答 2

3

lambda 持有引用的承诺p被移出并超出范围。您将需要一个额外的间接级别，以便承诺永远不会移动。

auto pp = std::make_unique<std::promise<int>>();
std::thread t ([p = pp.get()] { // <--- p is a promise<int>*
    std::cout << 1;
    p->set_value(1);
});

这样，promise 永远不会移动，您只需移动指针。lambda 获得一个指向 promise 的常规非拥有指针。

在这里看到它。

于 2019-03-09T20:51:37.313 回答
1

你的问题我没有答案。至少，我还没有。但是，似乎还没有其他答案出现，我觉得你的问题很有趣，所以让我们试试这个：

#include <iostream>
#include <thread>
#include <vector>
#include <future>
#include <memory>

class Test {        
    public:
    std::thread t;
    std::unique_ptr<std::promise<int>> pp;
    Test(std::thread&& rt, std::unique_ptr<std::promise<int>>&& rpp)
      : t(std::move(rt)), pp(std::move(rpp)) {}
};

int main()
{
    std::vector<Test> tests;

    {
        auto pp = std::make_unique<std::promise<int>>();
        std::thread t ([&pp]{
            std::cout << 1;
            pp->set_value(1);
        });
        tests.push_back(Test(std::move(t), std::move(pp)));
    }  

    for(Test& mytest : tests)
    {
        mytest.t.join();
    }
}

你看到我在那里做了什么吗？我通过智能指针间接获得了 Promise 的所有权。我们知道智能指针会优雅地销毁，因此这段代码永远不会移动 Promise 本身，而只会移动指向 Promise 的指针。然而代码仍然存在段错误。

那么我们确定承诺实际上是导致段错误的原因吗？

也许承诺确实导致了段错误，但现在至少我们有另一种方法来解决这个问题——除非你已经尝试过了。

于 2019-03-09T20:35:36.220 回答