Question

我处在一种情况下，我有一个连续的线程正在处理一些输入。但是，有时工作负荷太高，相应的未来不会等待结果。在这种情况下我需要释放一些资源，因为计算结果将不被执行（被标记为能够被释放，在其他地方）。

承诺是否有可能知道各自的未来已停止等待？或者我可以通过其他方式实现这种效果吗？（shared_future，...？）

作为概念的概要，我修改了std::promise example，以便您更容易理解我的意思：

using namespace std::chrono_literals;

void accumulate(std::vector<int>::iterator first,
                std::vector<int>::iterator last,
                std::promise<int> accumulate_promise)
{
    int sum = std::accumulate(first, last, 0);

    /* Can I possibly know that the corresponding future has stopped 
     * waiting for this promise, at this very position? 
     */
    accumulate_promise.set_value(sum);
}

int main()
{
    std::vector<int> numbers = { 1, 2, 3, 4, 5, 6 };
    std::promise<int> accumulate_promise;
    std::future<int> accumulate_future = accumulate_promise.get_future();
    std::thread work_thread(accumulate, numbers.begin(), numbers.end(),
                            std::move(accumulate_promise));

    /* Do not wait forever */
    accumulate_future.wait_for(1ms);
}

Answer 1

不通过std::promise。您可以在承诺旁边添加一个令牌，以指示是否应该继续。

using namespace std::chrono_literals;

void accumulate(std::vector<int>::iterator first,
                std::vector<int>::iterator last,
                std::promise<int> accumulate_promise,
                std::atomic<bool> & cancellation_token)
{
    int sum = std::accumulate(first, last, 0);

    if (cancellation_token.load()) return;

    accumulate_promise.set_value(sum);
}

int main()
{
    std::vector<int> numbers = { 1, 2, 3, 4, 5, 6 };
    std::promise<int> accumulate_promise;
    std::atomic<bool> token(false);
    std::future<int> accumulate_future = accumulate_promise.get_future();
    std::thread work_thread(accumulate, numbers.begin(), numbers.end(),
                            std::move(accumulate_promise), std::ref(token));

    if (accumulate_future.wait_for(1ms) != std::future_status::ready)
    {
        token.store(true);
    }
}

std :: promise能否知道相应的std :: future已取消等待？

1 个答案: