Потокобезопасная обертка над объектом

Есть ли минусы, которые могут заставить не использовать подобные обертки.
Также подскажите, есть ли уже что-то подобное в stl или boost. Вот накидал пример:

SafeRef:

#include <vector>
#include <iostream>
#include <mutex>
template<typename RefType>
class SafeRef
{
public:
    SafeRef(std::mutex &mutex, RefType ref) : m_reference(ref), m_mutex(mutex)
    {
        m_mutex.lock();
    }
    SafeRef(SafeRef &&other)
        : m_mutex(other.m_mutex), m_reference(other.m_referance)
    {
    }
    RefType get() const { return m_reference; }
    ~SafeRef() { m_mutex.unlock(); }
private:
    std::mutex &m_mutex;
    RefType m_reference;
};

Тестовый код:

class SomeObj
{
public:
    SafeRef<const std::vector<int>&> getVector() const
    {
        return SafeRef<const std::vector<int>&>(m_mutex, m_vector);
    }
    void reserve(int n)
    {
        std::lock_guard<std::mutex>(this->m_mutex);
        m_vector.reserve(n);
    }
    void addElement(int i)
    {
        std::lock_guard<std::mutex>(this->m_mutex);
        m_vector.push_back(i);
    }
private:
    mutable std::mutex m_mutex;
    std::vector<int> m_vector; //Большой вектор, копирование очень затратно
};
void write(SomeObj &obj)
{
    obj.reserve(500);
    for (int i = 0; i < 500; i++)
    {
        obj.addElement(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}
void read(const SomeObj &obj)
{
    for (int i = 0; i < 5; i++)
    {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        auto v = obj.getVector();
        std::cout << v.get().size() << std::endl;
    }
}
int main()
{
    SomeObj obj;
    std::thread thread1(&write, std::ref(obj));
    std::thread thread2(&read, std::ref(obj));
    thread2.join();
    thread1.join();
    return 0;
}