Классы синхронизации С++ в Win32 и Solaris 2.x

Класс Mutex

class Mutex {
 private:
 CRITICAL_SECTION lock;

 public:
 Mutex(void) { InitializeCriticalSection(&lock); }
 void Lock(void) { EnterCriticalSection(&lock); }
 void Unlock(void) { LeaveCriticalSection(&lock); }
}; 

class Mutex {
 private:
 mutex_t structure_lock; // structure access lock
 mutex_t lock; // mutex
 thread_t owner; // owner of mutex
 unsigned int count; // # of times owner locked mutex

 public:
 Mutex(void) { 
 mutex_init(&structure_lock, USYNC_THREAD, (void*)0);
 mutex_init(&lock, USYNC_THREAD, (void*)0);
 }

 ~Mutex(void) {
 mutex_destroy(&structure_lock);
 mutex_destroy(&lock);
 }

 void Lock(void) {
 mutex_lock(&structure_lock);
 if (owner == thr_self()) { // this thread already owns the lock
 count++;
 mutex_unlock(&structure_lock);
 }
 else { 
 // try to obtain the mutex. if we cannot do so immediately, release 
 // the structure lock and wait on the mutex.
 if (mytex_trylock(&lock) != 0) {
 mutex_unlock(&structure_lock);
 mutex_lock(&lock);
 mutex_lock(&structure_lock);
 owner = thr_self();
 }
 mutex_unlock(&structure_lock);
 }
 }

 void Unlock(void) {
 mutex_lock(&structure_lock);
 if ((owner == thr_self()) && (--count == 0)) 
 mutex_unlock(&lock);
 mutex_unlock(&structure_lock);
 }
}; 

class SafeInteger : private Mutex {
 private:
 int value;

 public:
 void SetValue(int new_value) {
 Lock();
 value = new_value;
 Unlock();
 }

 int GetValue(void) {
 Lock();
 int ret_value = value;
 Unlock();
 return ret_value;
 }
}; 

Класс Semaphore

class Semaphore {
 private:
 HANDLE semaphore;

 public:
 Semaphore(void) {
 CreateSemaphore((void *)0, 0, 0x7ffffff, (void*)0);
 }

 Semaphore(int available) {
 CreateSemaphore((void *)0, available, 0x7ffffff, (void*)0);
 }

 ~Semaphore(void) {
 CloseHandle(semaphore);
 }

 void Wait(void) {
 WaitForSingleObject(semaphore, INFINITE);
 }

 void Post(void) {
 ReleaseSemaphore(semaphore, 1, (void*)0);
 }

 void Post(int how_many) {
 ReleaseSemaphore(semaphore, how_many, (void*)0);
 }
}; 

class Semaphore {
 private:
 sema_t semaphore;

 public:
 Semaphore(void) {
 sema_init(&semaphore, 0, USYNC_PROCESS, (void*)0);
 }

 Semaphore(int available) {
 sema_init(&semaphore, available, USYNC_PROCESS, (void*)0);
 }

 ~Semaphore(void) {
 sema_destroy(&semaphore);
 }

 void Post(void) {
 sema_post(&semaphore);
 }

 void Post(int how_many) {
 while (how_many-- 0) sema_post(&semaphore);
 }

 void Wait(void) {
 sema_wait(&semaphore);
 }
}; 

template class QueueEntry : public T {
 public:
 T value;
 QueueEntry* next;

 QueueEntry(const T& item_value) {
 value = item_value;
 next = (QueueEntry*)0;
 }
};

template class Queue : private Semaphore : private Mutex {
 private:
 QueueEntry* head;
 QueueEntry* tail;

 public:
 Queue(void) {
 head = tail = (QueueEntry*)0;
 }

 void Add(const T& item_value) {
 Lock();
 if (tail == QueueEntry*)0)
 head = tail = new QueueEntry(item_value);
 else {
 tail-next = new QueueEntry(item_value);
 tail = tail-next;
 }
 Unlock();
 Post(); // wake up any waiting threads
 }

 T Wait(void) {
 Semaphore::Wait(); // wait for something to show up
 Lock();
 T value = head-value;
 QueueEntry* old = head;
 head = head-next;
 delete old;
 if (head == (QueueEntry*)0)
 tail = (QueueEntry*)0;
 Unlock();
 return value;
 }
};

Класс Event

class Event {
 private:
 HANDLE event;

 public:
 Event(void) {
 event = CreateEvent((void*)0, TRUE, FALSE, (void)0);
 }

 ~Event(void) {
 CloseHandle(event);
 }

 void Signal(void) {
 PulseEvent(event);
 }

 void Wait(void) {
 WaitForSingleObject(event, INFINITE);
 }
}; 

class Event {
 private:
 cond_t event;

 // in order to wait on a condition variable you must have a locked
 // mutex, which we don't really need.
 mutex_t dummy_mutex;

 public:
 Event(void) {
 cond_init(&event, USYNC_PROCESS, (void*)0);
 mutex_init(&dummy_mutex, USYNC_PROCESS, (void*)0);
 }

 ~Event(void) {
 event_destroy(&event);
 }

 void Signal(void) {
 cond_broadcast(&event);
 }

 void Wait(void) {
 mutex_lock(&dummy_mutex);
 cond_wait(&event, &dummy_mutex);
 mutex_unlock(&dummy_mutex);
 }
};