guicast/mutex.C

   1 #ifndef NO_GUICAST
   2 #include "bcsignals.h"
   3 #endif
   4 #include "mutex.h"
   5
   6 Mutex::Mutex(char *title, int recursive)
   7 {
   8         this->title = title;
   9         pthread_mutexattr_t attr;
  10         pthread_mutexattr_init(&attr);
  11         pthread_mutex_init(&mutex, &attr);
  12         pthread_mutex_init(&recursive_lock, &attr);
  13         count = 0;
  14         this->recursive = recursive;
  15         thread_id = 0;
  16         thread_id_valid = 0;
  17 }
  18
  19 Mutex::~Mutex()
  20 {
  21         pthread_mutex_destroy(&mutex);
  22         pthread_mutex_destroy(&recursive_lock);
  23 #ifndef NO_GUICAST
  24         UNSET_ALL_LOCKS(this);
  25 #endif
  26 }
  27
  28 int Mutex::lock(char *location)
  29 {
  30 // Test recursive owner and give up if we already own it
  31         if(recursive)
  32         {
  33                 pthread_mutex_lock(&recursive_lock);
  34                 if(thread_id_valid && pthread_self() == thread_id)
  35                 {
  36                         count++;
  37                         pthread_mutex_unlock(&recursive_lock);
  38                         return 0;
  39                 }
  40                 pthread_mutex_unlock(&recursive_lock);
  41         }
  42
  43
  44 #ifndef NO_GUICAST
  45         SET_LOCK(this, title, location);
  46 #endif
  47         if(pthread_mutex_lock(&mutex)) perror("Mutex::lock");
  48
  49
  50
  51 // Update recursive status for the first lock
  52         if(recursive)
  53         {
  54                 pthread_mutex_lock(&recursive_lock);
  55                 count = 1;
  56                 thread_id = pthread_self();
  57                 thread_id_valid = 1;
  58                 pthread_mutex_unlock(&recursive_lock);
  59         }
  60         else
  61         {
  62                 count = 1;
  63         }
  64
  65
  66 #ifndef NO_GUICAST
  67         SET_LOCK2
  68 #endif
  69         return 0;
  70 }
  71
  72 int Mutex::unlock()
  73 {
  74 // Remove from recursive status
  75         if(recursive)
  76         {
  77                 pthread_mutex_lock(&recursive_lock);
  78                 count--;
  79 // Still locked
  80                 if(count > 0)
  81                 {
  82                         pthread_mutex_unlock(&recursive_lock);
  83                         return 0;
  84                 }
  85 // Not owned anymore
  86                 thread_id = 0;
  87                 thread_id_valid = 0;
  88                 pthread_mutex_unlock(&recursive_lock);
  89         }
  90         else
  91                 count = 0;
  92
  93
  94 #ifndef NO_GUICAST
  95         UNSET_LOCK(this);
  96 #endif
  97
  98         if(pthread_mutex_unlock(&mutex)) perror("Mutex::unlock");
  99         return 0;
 100 }
 101
 102 int Mutex::trylock()
 103 {
 104         return pthread_mutex_trylock(&mutex);
 105 }
 106
 107 int Mutex::is_locked()
 108 {
 109         return count;
 110 }
 111
 112 int Mutex::reset()
 113 {
 114         pthread_mutex_destroy(&mutex);
 115         pthread_mutexattr_t attr;
 116         pthread_mutexattr_init(&attr);
 117         pthread_mutex_init(&mutex, &attr);
 118         count = 0;
 119         thread_id = 0;
 120         thread_id_valid = 0;
 121 #ifndef NO_GUICAST
 122         UNSET_ALL_LOCKS(this)
 123 #endif
 124         return 0;
 125 }