如何解决 std::get<>() 缺乏并发规范的问题

Question

以下代码块：

1. 技术上无效，因为std::get<>() 不是线程安全的。参考：Is using `std::get<I>` on a `std::tuple` guaranteed to be thread-safe for different values of `I`?

2. 据我所知，现在和可预见的未来，在所有 std::tuple<> 的实施中都是有效的。

    #include <tuple>
    #include <atomic>
    #include <thread>

    // Out of my control
    using data_t = std::tuple<int, int, int, int>;
    void foo(data_t); 
    //

    int main() {
        data_t landing;
        std::atomic<int> completed = 0;

        // Whichever thread pings last will be the one performing foo()
        auto ping = [&](){
            if(++completed == 4) {
                foo(landing);
            }
        };

        std::thread a([&](){ std::get<0>(landing) = 1; ping(); });
        std::thread b([&](){ std::get<1>(landing) = 2; ping(); });
        std::thread c([&](){ std::get<2>(landing) = 3; ping(); });
        std::thread d([&](){ std::get<3>(landing) = 4; ping(); });

        a.join();
        b.join();
        c.join();
        d.join();

        return 0;
    }

为了让事情变得更有趣，实际的代码充满了可变参数模板，因此编写一个一次性着陆台结构来处理这种情况并不能解决问题。它必须是一个通用的解决方案。

我目前的选择是：

• 使用改写后的 std::get<> 文档有效地重新实现 std::tuple<>，这既浪费时间又浪费代码。
• 推动std::get<>(std::tuple) 的提案以提供类似于std::vector<> 的保证，并记录代码仅在尚未发布的标准版本中有效的事实。
• 忽略这个问题，相信事实上，这几乎肯定总是有效的。

这些在短期内都不是特别好...所以我的问题是：

• 我是否遗漏了使第 2 点无效的内容？
• 是否有更好的解决方法可以让实现在技术上有效，而不必支持过多的额外代码。
• 欢迎对此主题提出任何其他意见。

Answer 1

推动std::get<>(std::tuple) 的提案以提供类似于std::vector<> 的保证，并记录代码仅在该标准尚未发布的版本中有效的事实。

我认为这是要走的路，因为它为整个 C++ 社区提供了价值，不应该成为实施者的负担。这也是write your first proposal的绝佳机会。

我建议这样做，现在假设这会起作用，即使它是 UB。如果您的软件是超级关键的（例如飞行控制系统），并且您希望 100% 确定您不依赖于将来可能会损坏的东西......然后实现您自己的 tuple。

Answer 2

template<class...Ts>
std::tuple< std::remove_reference_t<T>* >
to_pointers( std::tuple<Ts...>& );

template<class T0, class...Ts>
std::array<T0, 1+sizeof...(Ts)>
to_array( std::tuple<T0, Ts...> const& );

写下这些。

int main() {
    data_t landing;
    std::atomic<int> completed = 0;

    // Whichever thread pings last will be the one performing foo()
    auto ping = [&](){
        if(++completed == 4) {
            foo(landing);
        }
    };

    auto arr = to_array(to_pointers(landing));

    std::thread a([&](){ *arr[0] = 1; ping(); });
    std::thread b([&](){ *arr[1] = 2; ping(); });
    std::thread c([&](){ *arr[2] = 3; ping(); });
    std::thread d([&](){ *arr[3] = 4; ping(); });

    a.join();
    b.join();
    c.join();
    d.join();

    return 0;
}

我们通过指向元组的指针而不是通过std::get 访问元组元素。问题出在std::get的规范中；一旦您拥有指向保证存在于元组中的独立对象的独立指针，您就不会出现竞争条件。

所以我们将元组转换为一个线程中的指针数组（基本上是免费的），然后在线程中安全地使用它。