Создание класса С++ a Monitor (в параллельном смысле)
Я хочу, чтобы только один поток за один раз мог запускать метод моего класса С++. Другими словами, заставить класс вести себя как Monitor.
Есть ли шаблон, templatized способ сделать это или какой-то класс Boost, который я могу использовать? Потому что моя единственная идея до сих пор заключается в добавлении члена Critical Section и его приобретении в начале каждого метода и выпуске в конце (с использованием, конечно, RAII). Но это кажется очень избыточным, и я не могу его повторно использовать для другого класса.
Ответы
Ответ 1
Вы можете добиться этого с помощью разумного использования operator-> и современного С++, который дает гораздо более чистый синтаксис, чем ранее принятый ответ:
template<class T>
class monitor
{
public:
template<typename ...Args>
monitor(Args&&... args) : m_cl(std::forward<Args>(args)...){}
struct monitor_helper
{
monitor_helper(monitor* mon) : m_mon(mon), m_ul(mon->m_lock) {}
T* operator->() { return &m_mon->m_cl;}
monitor* m_mon;
std::unique_lock<std::mutex> m_ul;
};
monitor_helper operator->() { return monitor_helper(this); }
monitor_helper ManuallyLock() { return monitor_helper(this); }
T& GetThreadUnsafeAccess() { return m_cl; }
private:
T m_cl;
std::mutex m_lock;
};
Идея заключается в том, что вы используете оператор стрелки для доступа к базовому объекту, но возвращает объект-помощник, который блокирует и затем разблокирует мьютекс вокруг вашего вызова функции. Затем с помощью магии языка, повторно применяющего operator->, вы получаете ссылку на базовый объект.
Использование:
monitor<std::vector<int>> threadSafeVector {5};
threadSafeVector->push_back(0);
threadSafeVector->push_back(1);
threadSafeVector->push_back(2);
// Create a bunch of threads that hammer the vector
std::vector<std::thread> threads;
for(int i=0; i<16; ++i)
{
threads.push_back(std::thread([&]()
{
for(int i=0; i<1024; ++i)
{
threadSafeVector->push_back(i);
}
}));
}
// You can explicitely take a lock then call multiple functions
// without the overhead of a relock each time. The 'lock handle'
// destructor will unlock the lock correctly. This is necessary
// if you want a chain of logically connected operations
{
auto lockedHandle = threadSafeVector.ManuallyLock();
if(!lockedHandle->empty())
{
lockedHandle->pop_back();
lockedHandle->push_back(-3);
}
}
for(auto& t : threads)
{
t.join();
}
// And finally access the underlying object in a raw fashion without a lock
// Use with Caution!
std::vector<int>& rawVector = threadSafeVector.GetThreadUnsafeAccess();
rawVector.push_back(555);
// Should be 16393 (5+3+16*1024+1)
std::cout << threadSafeVector->size() << std::endl;
Ответ 2
Сначала создайте общий класс монитора. С мощью С++ 11 вы можете сделать это так просто:
template <class F>
struct FunctionType;
template <class R, class Object, class... Args>
struct FunctionType<R (Object::*)(Args...)> {
typedef R return_type;
};
template <class R, class Object, class... Args>
struct FunctionType<R (Object::*)(Args...) const> {
typedef R return_type;
};
template <class Object_>
class Monitor {
public:
typedef Object_ object_type;
template <class F, class... Args >
typename FunctionType<F>::return_type operation(const F& f, Args... args)
{
critical_section cs;
return (object.*f)(args...);
}
template <class F, class... Args >
typename FunctionType<F>::return_type operation(const F& f, Args... args) const
{
critical_section cs;
return (object.*f)(args...);
}
private:
object_type object;
class critical_section {};
};
Конечно, critical_section реализация зависит от вас. Я рекомендую POSIX или некоторые BOOST.
Он готов к использованию прямо сейчас:
Monitor<std::vector<int> > v;
v.operation((void (std::vector<int>::*)(const int&)) &std::vector<int>::push_back, 1);
v.operation((void (std::vector<int>::*)(const int&)) &std::vector<int>::push_back, 2);
size = v.operation(&std::vector<int>::size);
std::cout << size << std::endl;
Как вы можете видеть, иногда вам нужно явно указать, какую функцию-член вы хотите вызвать - std::vector < > имеет более одного push_back...
Для компиляторов, которые до сих пор не поддерживают вариационный шаблон - решение без него ниже - у меня есть время до двух аргументов - это очень неудобно - при необходимости - добавить функцию с большим количеством аргументов:
template <class F>
struct FunctionType;
template <class R, class Object>
struct FunctionType<R (Object::*)()> {
typedef R return_type;
};
template <class R, class Object>
struct FunctionType<R (Object::*)() const> {
typedef R return_type;
};
template <class R, class Object, class Arg1>
struct FunctionType<R (Object::*)(Arg1)> {
typedef R return_type;
};
template <class R, class Object, class Arg1>
struct FunctionType<R (Object::*)(Arg1) const> {
typedef R return_type;
};
template <class R, class Object, class Arg1, class Arg2>
struct FunctionType<R (Object::*)(Arg1,Arg2)> {
typedef R return_type;
};
template <class R, class Object, class Arg1, class Arg2>
struct FunctionType<R (Object::*)(Arg1,Arg2) const> {
typedef R return_type;
};
template <class Object_>
class Monitor {
public:
typedef Object_ object_type;
template <class F>
typename FunctionType<F>::return_type operation(const F& f)
{
critical_section cs;
return (object.*f)();
}
template <class F>
typename FunctionType<F>::return_type operation(const F& f) const
{
critical_section cs;
return (object.*f)();
}
template <class F, class Arg1>
typename FunctionType<F>::return_type operation(const F& f, Arg1 arg1)
{
critical_section cs;
return (object.*f)(arg1);
}
template <class F, class Arg1>
typename FunctionType<F>::return_type operation(const F& f, Arg1 arg1) const
{
critical_section cs;
return (object.*f)(arg1);
}
template <class F, class Arg1, class Arg2>
typename FunctionType<F>::return_type operation(const F& f, Arg1 arg1, Arg2 arg2)
{
critical_section cs;
return (object.*f)(arg1, arg2);
}
template <class F, class Arg1, class Arg2>
typename FunctionType<F>::return_type operation(const F& f, Arg1 arg1, Arg2 arg2) const
{
critical_section cs;
return (object.*f)(arg1, arg2);
}
private:
object_type object;
class critical_section {};
};
