mt/Mutex.hpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #ifndef anna_core_mt_Mutex_hpp
  10 #define anna_core_mt_Mutex_hpp
  11
  12 #include <pthread.h>
  13
  14 #include <anna/core/mt/Safe.hpp>
  15
  16 namespace anna {
  17
  18 /**
  19    Clase para implementar secciones criticas no-reentrantes. El uso general sera el siguiente:
  20
  21    \code
  22       mutex.lock ();
  23
  24       try {
  25        <implementacion de la seccion critica>
  26
  27         mutex.unlock ();
  28       }
  29       catch (Exception&) {
  30         mutex.unlock ();
  31         .... tratamiento de la excepcion ...
  32       }
  33    \endcode
  34
  35    La funcionalidad de esta clase solo estara disponible en aplicaciones multithread.
  36
  37    @see anna::Guard
  38    @see anna::Thread
  39    @see anna::Semaphore
  40 */
  41 class Mutex : public Safe {
  42 public:
  43   struct Mode { enum _v { Recursive, Strict }; };
  44   /**
  45     Constructor.
  46   */
  47   explicit Mutex(const Mode::_v mode = Mode::Recursive);
  48
  49   /**
  50     Destructor.
  51   */
  52   virtual ~Mutex();
  53
  54   virtual void lock() throw(RuntimeException);
  55
  56   virtual void unlock() throw();
  57
  58   /**
  59    * Devuelve \em true en caso de que haya conseguido bloquear el mutex, o
  60    * \em false en otro caso.
  61    * \return \em true en caso de que haya conseguido bloquear el mutex, o
  62    * \em false en otro caso.
  63    */
  64   bool trylock() throw(RuntimeException);
  65
  66   /**
  67    * Operador de conversión.
  68    * \return El \em pthread_mutex_t asociado a esta instancia.
  69    */
  70   operator const pthread_mutex_t*() const throw() {
  71 #ifdef _MT
  72     return &a_id;
  73 #else
  74     return NULL;
  75 #endif
  76   }
  77
  78 private:
  79 #ifdef _MT
  80   pthread_mutex_t a_id;
  81 #endif
  82
  83   Mutex(const Mutex& other);
  84 };
  85
  86 /**
  87  * Macro que incorpora la definición de un Mutex e implementa los métodos \em lock y \em unlock
  88  * en la clase desde la que se invoca.
  89  *
  90  * \warning Debe invocarse desde la parte privada de la clase para asegurar que las secciones críticas de la
  91  * misma sólo se activaran mediante anna::Guard<T>, que es la forma más segura y fácil.
  92  */
  93 #define anna_declare_mutex(ClassName) \
  94    anna::Mutex a_autoMutex; \
  95    void lock () throw (anna::RuntimeException) { a_autoMutex.lock (); } \
  96    void unlock () throw () { a_autoMutex.unlock (); } \
  97    friend class anna::Guard <ClassName >;
  98
  99 #define anna_access_mutex a_autoMutex
 100
 101 } //namespace anna
 102
 103 #endif