mt/ThreadManager.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_ThreadManager_hpp
  10 #define anna_core_mt_ThreadManager_hpp
  11
  12 #include <string>
  13
  14 #include <anna/core/mt/SafeRecycler.hpp>
  15 #include <anna/core/mt/Thread.hpp>
  16
  17 #include <anna/core/core.hpp>
  18
  19 namespace anna {
  20
  21 class Semaphore;
  22
  23 /**
  24    Gestor de threads. Optimiza la creacin y uso de los threads. Como ventaja adicional limita
  25    el numero de threads que puede ser creados.
  26 */
  27 class ThreadManager : SafeRecycler <Thread> {
  28 public:
  29   /**
  30      Modos de funcionamiento
  31      \see ThreadManager
  32   */
  33   struct Mode {
  34     enum _v {
  35       None,
  36       Unlimit, /**< Permite crear tantos threads como sea necesario. */
  37       ExceptionWhenFull, /**< Si no hay ningun thread libre lanza una excepcion */
  38       LockWhenFull /**< Si no hay ningun thread libre el metodo que invoca a #createThread queda
  39          bloqueado hasta que algun otro thread termine su tarea. */
  40     };
  41
  42     anna_declare_enum(Mode);
  43   };
  44
  45   typedef iterator thread_iterator;
  46
  47   /**
  48      Constructor.
  49      @param name Nombre logico del la gestor de threads.
  50      \param mode Modo de funcionamiento de ester gestor de threads.
  51      @param maxSize Numero maximo de threads que seran creados.
  52      \param flags Flags aplicados a los threads creados por este gestor.
  53   */
  54   ThreadManager(const char* name, const Mode::_v mode, const int maxSize, const int flags = Thread::Flag::None);
  55
  56   /**
  57      Constructor.
  58      Crea un gestor de thread que puede crecer con un número ilimitado de threads.
  59      @param name Nombre logico del la gestor de threads.
  60      \param flags Flags aplicados a los threads creados por este gestor.
  61   */
  62   ThreadManager(const char* name, const int flags = Thread::Flag::None);
  63
  64   /**
  65      Destructor.
  66   */
  67   virtual ~ThreadManager();
  68
  69   /**
  70    * Devuelve el nombre asociado a este gestor.
  71    * \return el nombre asociado a este gestor.
  72    */
  73   const std::string& getName() const throw() { return a_name; }
  74
  75   /**
  76      Obtiene la instancia de un thread. El thread sólo se liberará de forma automática cuando se termine la ejecución del mismo.
  77      \return La instancia de un thread.
  78
  79      \warning Solo debe haber un único punto de creación de thread's por cada instancia de esta clase.
  80   */
  81   Thread* createThread() throw(RuntimeException);
  82
  83   /**
  84    * Bloquea el proceso hasta que todos los threads lanzados por este gestor hayan terminado su ejecución.
  85    * \warning \li No debería invocarse desde un thread que haya sido creado por este gestor.
  86    *          \li Los threads deberían crearse con el flag Thread::Flag::Joinable.
  87    */
  88   void join() throw(RuntimeException);
  89
  90   /**
  91      Devuelve un iterador al comienzo de la lista de threads.
  92      \return un iterador al comienzo de la lista de threads.
  93   */
  94   thread_iterator thread_begin() throw() { return begin(); }
  95
  96   /**
  97      Devuelve un iterador al final de la lista de threads.
  98      \return un iterador al final de la lista de threads.
  99   */
 100   thread_iterator thread_end() throw() { return end(); }
 101
 102   /**
 103      Devuelve el thread referenciado por el iterador recibido como parametro.
 104      \param ii Iterador.
 105      \return el thread referenciado por el iterador recibido como parametro.
 106   */
 107   static Thread* thread(thread_iterator ii) throw() { return SafeRecycler <Thread>::data(ii); }
 108
 109   /**
 110    * Devuelve una cadena con la información relevante sobre este gestor de threads
 111    * \return una cadena con la información relevante sobre este gestor de threads
 112    */
 113   std::string asString() const throw();
 114
 115 private:
 116   const std::string a_name;
 117   const Mode::_v a_mode;
 118   const int a_maxSize;
 119   Semaphore* a_semaphore;
 120   const int a_threadFlags;
 121   bool a_destroying;
 122
 123   // Se invoca cuando el thread detecta que va a terminar y que tiene una factoria asociada.
 124   void releaseThread(Thread* thread) throw(RuntimeException);
 125
 126   friend class Thread;
 127 };
 128
 129 } //namespace anna
 130
 131 #endif
 132