为什么 std::lock_guard/std::unique_lock 不使用类型擦除？

Question

为什么 std::lock_guard and std::unique_lock 需要将锁类型指定为模板参数？

考虑以下备选方案。首先，在一个detail命名空间中，有类型擦除classes（一个非模板抽象基class，和一个模板派生class）：

#include <type_traits>
#include <mutex>
#include <chrono>
#include <iostream>

namespace detail {

    struct locker_unlocker_base {
        virtual void lock() = 0;
        virtual void unlock() = 0;
    };

    template<class Mutex>
    struct locker_unlocker : public locker_unlocker_base {
        locker_unlocker(Mutex &m) : m_m{&m} {}
        virtual void lock() { m_m->lock(); }
        virtual void unlock() { m_m->unlock(); }
        Mutex *m_m;
    };
}

现在 te_lock_guard，类型擦除锁保护器，在构造时简单地放置消息正确类型的对象（没有动态内存分配）：

class te_lock_guard {
public:
    template<class Mutex>
    te_lock_guard(Mutex &m) {
        new (&m_buf) detail::locker_unlocker<Mutex>(m);
        reinterpret_cast<detail::locker_unlocker_base *>(&m_buf)->lock();
    }
    ~te_lock_guard() {
        reinterpret_cast<detail::locker_unlocker_base *>(&m_buf)->unlock();
    }

private:
    std::aligned_storage<sizeof(detail::locker_unlocker<std::mutex>), alignof(detail::locker_unlocker<std::mutex>)>::type m_buf;
};

我已经检查了性能与标准库的 classes:

int main() {
    constexpr std::size_t num{999999};
    {
        std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
        for(size_t i = 0; i < num; ++i) {
            std::mutex m;
            te_lock_guard l(m);
        }
        std::chrono::steady_clock::time_point end= std::chrono::steady_clock::now();
        std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << std::endl;
    }
    {
        std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
        for(size_t i = 0; i < num; ++i) {
            std::mutex m;
            std::unique_lock<std::mutex> l(m);
        }
        std::chrono::steady_clock::time_point end= std::chrono::steady_clock::now();
        std::cout << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << std::endl;
    }
}

将 g++ 与 -O3 结合使用，没有统计上显着的性能损失。

Answer 1

因为这使实现变得复杂，但没有任何明显的好处，并且隐藏了 std::lock_guard 和 std::unique_lock 知道它们在编译时保护的锁类型的事实。

您的解决方案是针对 class 模板参数推导不会在构造期间发生这一事实的解决方法 - 这将在即将发布的标准中解决。

需要指定锁类型是烦人的样板文件，将在 C++17 中解决（不仅针对锁守卫） 感谢 Template parameter deduction for constructors (P0091R3) 提议。

提案（已被接受），允许从构造函数中推导出模板参数，从而无需 make_xxx(...) 辅助函数或显式指定编译器需要的类型名称应该可以推导出：

// Valid C++17
for(size_t i = 0; i < num; ++i) {
    std::mutex m;
    std::unique_lock l(m);
}

Answer 2

继续C++17...与此同时，不需要类型擦除。模板函数参数推导为我们提供了一个简单的帮手：

template<class Mutex>
auto make_lock(Mutex& m)
{
    return std::unique_lock<Mutex>(m);
}

...

std::mutex m;
std::recursive_mutex m2;

auto lock = make_lock(m);
auto lock2 = make_lock(m2);

为什么 std::lock_guard/std::unique_lock 不使用类型擦除？

Why doesn't std::lock_guard/std::unique_lock use type erasure?

c++

multithreading

type-erasure