JMutex.hh

Go to the documentation of this file.

#ifndef __JLANG__JMUTEX__
#define __JLANG__JMUTEX__
 
#include <pthread.h>
 
/**
 * \file
 * Very basic lock facilities to be used in multithreaded programs.
 * \author cpellegrino
 */
 
namespace JSYNCHRONIZATION {}
namespace JPP { using namespace JSYNCHRONIZATION; }
 
namespace JSYNCHRONIZATION {
 
  /**
   * Scoped lock.
   *
   * The main purpose of this class is to provide an exception-safe locking
   * facility.
   * The lock on the mutex is acquired during construction, while the
   * unlock is performed in the destructor.
   *
   * Es:
   * Case 1, without scoped lock:
   * using namespace JSYNCHRONIZATION;
   * JMutex mutex;
   *
   * {
   *   mutex.lock();
   *   throwing_function(variable_to_protect); // <- this shall throw
   *   mutex.lock();                           // <- this call is never
   *                                           // executed -> deadlock
   * }
   *
   * Case 2, with scoped lock:
   * using namespace JSYNCHRONIZATION;
   * JMutex mutex;
   *
   * {
   *   JScopedLock(mutex);
   *   throwing_function(variable_to_protect); // <- this shall throw
   * } // the lock is released here automatically
   */
  template<typename Lockable>
  class JBasicScopedLock
  {
  private:
    Lockable* m_lock;
 
    /**
     * Neither copy-constructible nor copy-assignable
     */
    JBasicScopedLock(const JBasicScopedLock&);
    JBasicScopedLock(JBasicScopedLock&&);
    JBasicScopedLock operator =(const JBasicScopedLock&);
    JBasicScopedLock operator =(JBasicScopedLock&&);
 
  public:
 
    /**
     * Constructor
     *  \param  lock     a lockable object (e.g.\ JScopedLock)
     */
    explicit JBasicScopedLock(Lockable& lock)
      :
      m_lock(&lock)
    {
      m_lock->lock();
    }
 
    /**
     * Destructor
     */
    ~JBasicScopedLock()
    {
      unlock();
    }
 
    /**
     * Unlock the mutex.
     * \return    0 on success, an error code otherwise.
     *            See man 3p pthread_mutex_lock for further info.
     */
    int unlock()
    {
      return m_lock->unlock();
    }
  };
 
  /**
   * Mutex.
   */
  class JMutex
  {
    pthread_mutex_t m_mutex;
 
  public:
 
    /**
     * Constructor.
     */
    JMutex()
    {
      pthread_mutex_init(&m_mutex, 0);
    }
 
    /**
     * Destructor.
     */
    ~JMutex()
    {
      pthread_mutex_destroy(&m_mutex);
    }
 
    /**
     * Lock the mutex.
     * \return    0 on success, an error code otherwise.
     *            See man 3p pthread_mutex_lock for further info.
     */
    int lock()
    {
      return pthread_mutex_lock(&m_mutex);
    }
 
    /**
     * Try lock the mutex.
     * \return    0 on success, an error code otherwise.
     *            See man 3p pthread_mutex_lock for further info.
     */
    int try_lock()
    {
      return pthread_mutex_trylock(&m_mutex);
    }
 
    /**
     * Unlock the mutex.
     * \return    0 on success, an error code otherwise.
     *            See man 3p pthread_mutex_lock for further info.
     */
    int unlock()
    {
      return pthread_mutex_unlock(&m_mutex);
    }
 
    typedef JBasicScopedLock<JMutex> JScopedLock;
  };
 
} // ns JSYNCHRONIZATION
 
#endif // __JLANG__JMUTEX__