Ключевая проблема защиты общих данных с мутексом заключается в том, что нет простого способа связать мутекс с данными. Таким образом, относительно легко случайно написать код, который не блокирует правильный mutex или даже блокирует неправильный mutex, и компилятор не поможет вам.

std::mutex m1;
int value1;
std::mutex m2;
int value2;
int readValue1()
{
  boost::lock_guard<boost::mutex> lk(m1);
  return value1;
}
int readValue2()
{
  boost::lock_guard<boost::mutex> lk(m1); // oops: wrong mutex
  return value2;
}

Кроме того, управление блокировкой mutex также загромождает исходный код, что затрудняет понимание того, что происходит на самом деле.

Использование синхронизированного значения решает обе эти проблемы - mutex тесно связан со значением, поэтому вы не можете получить к нему доступ без замка, и все же семантика доступа по-прежнему проста. Для простых доступов синхронизированное значение ведет себя как указатель на Т; например:

boost::synchronized_value<std::string> value3;
std::string readValue3()
{
  return *value3;
}
void setValue3(std::string const& newVal)
{
  *value3=newVal;
}
void appendToValue3(std::string const& extra)
{
  value3->append(extra);
}

Обе формы отсчета указателей возвращают прокси-объект, а не реальную ссылку, чтобы гарантировать, что замок на mutex удерживается во время вызова назначения или метода, но это прозрачно для пользователя.

Семантика, похожая на указатель, очень хорошо работает для простых доступов, таких как назначение и вызовы функций-членов. Тем не менее, иногда вам нужно выполнить операцию, которая требует многократного доступа под защитой одного и того же замка, и это то, что обеспечивает метод синхронизации.

Вызывая синхронизацию (), вы получаете объект strict_lock_ptr, который содержит блокировку на mutex, защищающую данные, и который может быть использован для доступа к защищенным данным. Замок удерживается до тех пор, пока объект strict_lock_ptr не будет уничтожен, поэтому вы можете безопасно выполнять многочастные операции. Объект strict_lock_ptr также действует как указатель на T, как и синхронизированное значение, но на этот раз замок уже удерживается. Например, следующая функция добавляет следующий слэш к пути, удерживаемому в синхронизированном значении. Использование объекта strict_lock_ptr гарантирует, что строка не изменилась между запросом и обновлением.

void addTrailingSlashIfMissing(boost::synchronized_value<std::string> & path)
{
  boost::strict_lock_ptr<std::string> u=path.synchronize();
  if(u->empty() || (*u->rbegin()!='/'))
  {
    *u+='/';
  }
}

Хотя синхронизированное значение очень хорошо работает для защиты одного объекта типа T, ничто из того, что мы видели до сих пор, не решает проблему операций, требующих атомного доступа к нескольким объектам, если эти объекты не могут быть объединены в одну структуру, защищенную одним мутексом.

Одним из способов защиты доступа к двум объектам синхронизированного значения является построение строгого _lock_ptr для каждого объекта и использование их для доступа к соответствующим защищенным значениям; например:

synchronized_value<std::queue<MessageType> > q1,q2;
void transferMessage()
{
  strict_lock_ptr<std::queue<MessageType> > u1 = q1.synchronize();
  strict_lock_ptr<std::queue<MessageType> > u2 = q2.synchronize();
  if(!u1->empty())
  {
    u2->push_back(u1->front());
    u1->pop_front();
  }
}

Это хорошо работает в некоторых сценариях, но не во всех — если одни и те же два объекта обновляются вместе в разных разделах кода, то вам нужно позаботиться о том, чтобы объекты strict_lock_ptr были построены в одной последовательности во всех случаях, иначе у вас есть потенциал для тупика. Это то же самое, что и при приобретении любых двух мутексов.

Чтобы иметь возможность использовать алгоритмы блокировки без замков, нам нужно использовать уникальный_lock_ptr, который является Lockable.

synchronized_value<std::queue<MessageType> > q1,q2;
void transferMessage()
{
  unique_lock_ptr<std::queue<MessageType> > u1 = q1.unique_synchronize(boost::defer_lock);
  unique_lock_ptr<std::queue<MessageType> > u2 = q2.unique_synchronize(boost::defer_lock);
  boost::lock(u1,u2); // dead-lock free algorithm
  if(!u1->empty())
  {
    u2->push_back(u1->front());
    u1->pop_front();
  }
}

В то время как предыдущий заботится о тупике, доступ к синхронизированному значению через уникальный_lock_ptr требует блокировки, которая не навязывается интерфейсом. Альтернативой компиляторам, обеспечивающим стандартную библиотеку, поддерживающую подвижный std::tuple, является использование функции свободной синхронизации, которая блокирует все мутексы, связанные с синхронизированными значениями, и возвращает tuple os strict_lock_ptr.

synchronized_value<std::queue<MessageType> > q1,q2;
void transferMessage()
{
  auto lks = synchronize(u1,u2); // dead-lock free algorithm
  if(!std::get<1>(lks)->empty())
  {
    std::get<2>(lks)->push_back(u1->front());
    std::get<1>(lks)->pop_front();
  }
}

Синхронизированное значение имеет семантику значений, даже если синтаксис позволяет приблизиться к указателю (это только потому, что мы не можем определить умные ссылки).

#include <boost/thread/synchronized_value.hpp>
namespace boost
{
  template<typename T, typename Lockable = mutex>
  class synchronized_value
  {
  public:
    typedef T value_type;
    typedef Lockable mutex_type;
    synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);
    synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);
    synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);
    synchronized_value(synchronized_value const& rhs);
    synchronized_value(synchronized_value&& other);
    // mutation
    synchronized_value& operator=(synchronized_value const& rhs);
    synchronized_value& operator=(value_type const& val);
    void swap(synchronized_value & rhs);
    void swap(value_type & rhs);
    //observers
    T get() const;
  #if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
    explicit operator T() const;
  #endif
    strict_lock_ptr<T,Lockable> operator->();
    const_strict_lock_ptr<T,Lockable> operator->() const;
    strict_lock_ptr<T,Lockable> synchronize();
    const_strict_lock_ptr<T,Lockable> synchronize() const;
    deref_value operator*();;
    const_deref_value operator*() const;
  private:
    T value_; // for exposition only
    mutable mutex_type mtx_;  // for exposition only
  };
}

synchronized_value() noexcept(is_nothrow_default_constructible<T>::value);

synchronized_value(T const& other) noexcept(is_nothrow_copy_constructible<T>::value);

synchronized_value(synchronized_value const& rhs);

synchronized_value(T&& other) noexcept(is_nothrow_move_constructible<T>::value);

synchronized_value(synchronized_value&& other);

synchronized_value& operator=(synchronized_value const& rhs);

synchronized_value& operator=(value_type const& val);

T get() const;

#if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
  explicit operator T() const;
#endif

void swap(synchronized_value & rhs);

void swap(value_type & rhs);

strict_lock_ptr<T,Lockable> operator->();

const_strict_lock_ptr<T,Lockable> operator->() const;

strict_lock_ptr<T,Lockable> synchronize();

void fun(synchronized_value<vector<int>> & vec) {
  auto vec2=vec.synchronize();
  vec2.push_back(42);
  assert(vec2.back() == 42);
}

const_strict_lock_ptr<T,Lockable> synchronize() const;

deref_value operator*();;

const_deref_value operator*() const;

#include <boost/thread/synchronized_value.hpp>
namespace boost
{
#if ! defined(BOOST_THREAD_NO_SYNCHRONIZE)
  template <typename ...SV>
  std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv);
#endif
}

#include <boost/thread/concurrent_queues/queue_op_status.hpp>
namespace boost
{
   enum class queue_op_status { success = 0, empty, full, closed, busy }
}

#include <boost/thread/concurrent_queues/queue_base.hpp>
namespace boost
{
  template <typename ValueType, class SizeType=std::size_t>
  class queue_base
  {
  public:
    typedef ValueType value_type;
    typedef SizeType size_type;
    // Constructors/Assignment/Destructors
    virtual ~queue_base() {};
    // Observers
    virtual bool empty() const = 0;
    virtual bool full() const = 0;
    virtual size_type size() const = 0;
    virtual bool closed() const = 0;
    // Modifiers
    virtual void close() = 0;
    virtual void push_back(const value_type& x) = 0;
    virtual void push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual void pull_front(value_type&) = 0;
    virtual value_type pull_front() = 0;
    virtual queue_op_status try_push_back(const value_type& x) = 0;
    virtual queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status try_pull_front(value_type&) = 0;
    virtual queue_op_status nonblocking_push_back(const value_type& x) = 0;
    virtual queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status nonblocking_pull_front(value_type&) = 0;
    virtual queue_op_status wait_push_back(const value_type& x) = 0;
    virtual queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status wait_pull_front(value_type& elem) = 0;
  };
}

#include <boost/thread/concurrent_queues/queue_adaptor.hpp>
namespace boost
{
  template <typename Queue>
  class queue_adaptor : public queue_base<typename Queue::value_type, typename Queue::size_type>
  {
  public:
    typedef typename Queue::value_type value_type;
    typedef typename Queue::size_type size_type;
    // Constructors/Assignment/Destructors
    queue_adaptor();
    // Observers
    bool empty() const;
    bool full() const;
    size_type size() const { return queue.size(); }
    bool closed() const;
    // Modifiers
    void close();
    void push_back(const value_type& x);
    void push_back(BOOST_THREAD_RV_REF(value_type) x);
    void pull_front(value_type& x);
    value_type pull_front();
    queue_op_status try_push_back(const value_type& x);
    queue_op_status try_push_back(BOOST_THREAD_RV_REF(value_type) x);
    queue_op_status try_pull_front(value_type& x);
    queue_op_status nonblocking_push_back(const value_type& x);
    queue_op_status nonblocking_push_back(BOOST_THREAD_RV_REF(value_type) x);
    queue_op_status nonblocking_pull_front(value_type& x);
    queue_op_status wait_push_back(const value_type& x);
    queue_op_status wait_push_back(BOOST_THREAD_RV_REF(value_type) x);
    queue_op_status wait_pull_front(value_type& x);
  };
}

#include <boost/thread/concurrent_queues/queue_views.hpp>
namespace boost
{
  template <typename Queue>
  class queue_back_view;
  template <typename Queue>
  class queue_front_view
  template <class T>
  using queue_back = queue_back_view<queue_base<T>>;
  template <class T>
  using queue_front = queue_front_view<queue_base<T>>;
}

template <typename Queue>
class queue_back_view
{
public:
  typedef typename Queue::value_type value_type;
  typedef typename Queue::size_type size_type;
  // Constructors/Assignment/Destructors
  queue_back_view(Queue& q) noexcept;
  // Observers
  bool empty() const;
  bool full() const;
  size_type size() const;
  bool closed() const;
  // Modifiers
  void close();
  void push(const value_type& x);
  void push(BOOST_THREAD_RV_REF(value_type) x);
  queue_op_status try_push(const value_type& x);
  queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x);
  queue_op_status nonblocking_push(const value_type& x);
  queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x);
  queue_op_status wait_push(const value_type& x);
  queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x);
};

template <typename Queue>
class queue_front_view
{
public:
  typedef typename Queue::value_type value_type;
  typedef typename Queue::size_type size_type;
  // Constructors/Assignment/Destructors
  queue_front_view(Queue& q) BOOST_NOEXCEPT;
  // Observers
  bool empty() const;
  bool full() const;
  size_type size() const;
  bool closed() const;
  // Modifiers
  void close();
  void pull(value_type& x);
  value_type pull();
  queue_op_status try_pull(value_type& x);
  queue_op_status nonblocking_pull(value_type& x);
  queue_op_status wait_pull(value_type& x);
};

#include <boost/thread/sync_bounded_queue.hpp>
namespace boost
{
  struct sync_queue_is_closed : std::exception {};
  template <typename ValueType>
  class sync_bounded_queue;
  // Stream-like operators
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType&& elem);
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType const&elem);
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator>>(sync_bounded_queue<ValueType>& sbq, ValueType &elem);
}

#include <boost/thread/sync_bounded_queue.hpp>
namespace boost
{
  struct sync_queue_is_closed : std::exception {};
}

#include <boost/thread/sync_bounded_queue.hpp>
namespace boost
{
  template <typename ValueType>
  class sync_bounded_queue
  {
  public:
    typedef ValueType value_type;
    typedef std::size_t size_type;
    sync_bounded_queue(sync_bounded_queue const&) = delete;
    sync_bounded_queue& operator=(sync_bounded_queue const&) = delete;
    explicit sync_bounded_queue(size_type max_elems);
    template <typename Range>
    sync_bounded_queue(size_type max_elems, Range range);
    ~sync_bounded_queue();
    // Observers
    bool empty() const;
    bool full() const;
    size_type capacity() const;
    size_type size() const;
    bool closed() const;
    // Modifiers
    void push_back(const value_type& x);
    void push_back(value_type&& x);
    queue_op_status try_push_back(const value_type& x);
    queue_op_status try_push_back(value_type&&) x);
    queue_op_status nonblocking_push_back(const value_type& x);
    queue_op_status nonblocking_push_back(value_type&& x);
    void pull_front(value_type&);
    value_type pull_front();
    queue_op_status try_pull_front(value_type&);
    queue_op_status nonblocking_pull_front(value_type&);
    void close();
  };
}

explicit sync_bounded_queue(size_type max_elems);

template <typename Range>
sync_bounded_queue(size_type max_elems, Range range);

#include <boost/thread/sync_bounded_queue.hpp>
namespace boost
{
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType&& elem);
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator<<(sync_bounded_queue<ValueType>& sbq, ValueType const&elem);
}

#include <boost/thread/sync_bounded_queue.hpp>
namespace boost
{
  template <typename ValueType>
  sync_bounded_queue<ValueType>& operator>>(sync_bounded_queue<ValueType>& sbq, ValueType &elem);
}

#include <boost/thread/sync_queue.hpp>
namespace boost
{
  template <typename ValueType>
  class sync_queue;
  // Stream-like operators
  template <typename ValueType>
  sync_queue<ValueType>& operator<<(sync_queue<ValueType>& sbq, ValueType&& elem);
  template <typename ValueType>
  sync_queue<ValueType>& operator<<(sync_queue<ValueType>& sbq, ValueType const&elem);
  template <typename ValueType>
  sync_queue<ValueType>& operator>>(sync_queue<ValueType>& sbq, ValueType &elem);
}

#include <boost/thread/sync_queue.hpp>
namespace boost
{
  template <typename ValueType, class Container = csbl::devector<ValueType>>
  class sync_queue
  {
  public:
    typedef ValueType value_type;
    typedef Container underlying_queue_type;
    typedef typename Container::size_type size_type;
    sync_queue(sync_queue const&) = delete;
    sync_queue& operator=(sync_queue const&) = delete;
    sync_queue();
    explicit template <typename Range>
    sync_queue(Range range); // Not yet implemented
    ~sync_queue();
    // Observers
    bool empty() const;
    bool full() const;
    size_type size() const;
    bool closed() const;
    // Modifiers
    void push_back(const value_type& x);
    void push_back(value_type&& x);
    queue_op_status try_push_back(const value_type& x);
    queue_op_status try_push_back(value_type&&) x);
    queue_op_status nonblocking_push_back(const value_type& x);
    queue_op_status nonblocking_push_back(value_type&& x);
    void pull_front(value_type&);
    value_type pull_front();
    queue_op_status try_pull_front(value_type&);
    queue_op_status nonblocking_pull_front(value_type&);
    underlying_queue_type underlying_queue() noexcept;
    void close();
  };
}

explicit sync_queue();

bool full() const;

underlying_queue_type underlying_queue() noexcept;

#include <boost/thread/sync_queue.hpp>
namespace boost
{
  template <typename ValueType>
  sync_queue<ValueType>& operator<<(sync_queue<ValueType>& sbq, ValueType&& elem);
  template <typename ValueType>
  sync_queue<ValueType>& operator<<(sync_queue<ValueType>& sbq, ValueType const&elem);
}

#include <boost/thread/sync_queue.hpp>
namespace boost
{
  template <typename ValueType>
  sync_queue<ValueType>& operator>>(sync_queue<ValueType>& sbq, ValueType &elem);
}