原子类对象方法的用法

Question

I want to call methods of some class atomically from two threads. I have non-thead-safe class, from third-party library, but need to use this class like that:

Main thread:

Foo foo;
foo.method1(); // while calling Foo::method1 object foo is locked for another threads

Second thread:

foo.method2(); // wait while somewere calling another methods from foo

How to use std::atomic at this situation? Or may be another solution (exclude use mutex and lock before and unlock after calling methods from foo)?

Answer 1

You cannot use std::atomic with user-defined types that are not trivially copyable, and the Standard only provides a limited set of specializations for certain fundamental types. Here you can find the list of all the standard specializations of std::atomic .

One approach you may want to consider is to write a general-purpose wrapper that lets you provide callable objects to be executed in a thread-safe manner on the wrapped object. Something along these lines was once presented by Herb Sutter in one of his talks :

template<typename T>
class synchronized
{
public:
    template<typename... Args>
    synchronized(Args&&... args) : _obj{std::forward<Args>(args)...} { }

    template<typename F>
    void thread_safe_invoke(F&& f)
    {
        std::lock_guard<std::mutex> lock{_m};
        (std::forward<F>(f))(_obj);
    }

    // ...

private:
    T _obj;
    std::mutex _m;
};

This incurs some syntactic overhead in case you only want to call a single function in a thread-safe manner, but it also allows realizing transactions that must be performed atomically and may consist of more than one function call on the synchronized object.

This is how you could use it:

int main()
{
    synchronized<std::string> s{"Hello"};

    s.thread_safe_invoke([&] (auto& s)
    {
        std::cout << s.size() << " " << (s + s);
    });
}

For a deeper analysis and implementation guidance, you may refer to this article on the subject as well as this one .

Answer 2

Share a std::mutex between the different threads. Where ever you use foo , wrap the calls with a std::unique_lock