设计模式C++实现:监视器对象

监视器对象设计模式使并发方法的执行同步化，以确保任一时刻仅有一个方法在对象内运行。别名线程安全被动对象。

问题场景：应用程序包含被多个线程并发调用的对象。这些方法通常修改其对象的内部状态。为了并发线程内正确执行，有必要对对象的访问进行同步和调度。如果客户机必须显示的获取和释放底层同步机制，如信号、互斥或条件变量。那么并发应用程序更难编程。因此，对象应该负责确保它们需要同步的任何方法被透明的串行化。

代码示例：

#include <iostream>
#include <string>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <pthread.h>
using namespace std;
class Mutex
{
public:
Mutex()
{
pthread_mutex_init(&_lock, NULL);
}
virtual ~Mutex()
{
pthread_mutex_destroy(&_lock);
}
void Lock()
{
pthread_mutex_lock(&_lock);
}
void Unlock()
{
pthread_mutex_unlock(&_lock);
}
pthread_mutex_t* GetLock()
{
return &_lock;
}

private:
pthread_mutex_t _lock;

};
class TreadCond
{
public:
TreadCond()
{
pthread_cond_init(&m_cond, NULL);
}
virtual ~TreadCond()
{
pthread_cond_destroy(&m_cond);
}
void CondNotify()
{
pthread_cond_signal(&m_cond);
}
void CondWait(pthread_mutex_t* lock)
{
pthread_cond_wait(&m_cond, lock);
}

private:
pthread_cond_t m_cond;
};

class ScopedLock
{
public:
ScopedLock( Mutex& mutex_obj ) : _mutex_obj(mutex_obj)
{
_mutex_obj.Lock();
}
~ScopedLock()
{
_mutex_obj.Unlock();
}
private:
Mutex& _mutex_obj;

};
class MessageQueue
{
enum {MAX_SIZE = 100,};
public:
MessageQueue(int size = MAX_SIZE):
m_size(size),
m_mesageCount(0)

{

}
~MessageQueue()
{
delete m_array;
}

void put(int value)
{
ScopedLock lock(m_mutex);
while(i_full())
{
m_notFullCond.CondWait(m_mutex.GetLock());
cout<<"full"<<endl;
}
i_put(value);
//cout<<"put:"<<value<<endl;
m_notEmptyCond.CondNotify();
}
int get()
{
ScopedLock lock(m_mutex);
while(i_empt())
{
m_notEmptyCond.CondWait(m_mutex.GetLock());
cout<<"empt"<<endl;
}
int value = i_get();
//cout<<"get:"<<value<<endl;
m_notFullCond.CondNotify();
return value;
}
bool empt()
{
ScopedLock lock(m_mutex);
return i_empt();
}
bool full()
{
ScopedLock lock(m_mutex);
return i_full();
}
private:
bool i_empt()
{
return m_mesageCount == 0;
}
bool i_full()
{
return m_mesageCount == m_size;
}
void i_put(int value)
{
m_array[m_mesageCount] = value;
m_mesageCount++;
//cout<<"putmsgcout:"<<m_mesageCount<<endl;
}
int i_get()
{
int val = m_array[m_mesageCount-1];;
m_mesageCount--;
//cout<<"getmsgcout:"<<m_mesageCount<<endl;
return val;
}
private:
int m_size;
int m_array[MAX_SIZE];
int m_mesageCount;
Mutex m_mutex;
TreadCond m_notEmptyCond;
TreadCond m_notFullCond;
};
MessageQueue g_queue;
void *pthr_fun1(void *arg)
{
int i = 1;
while(i < 30000)
{
g_queue.put(i);
cout<<"thread1_put:"<<i<<endl;
i++;
}
}
void *pthr_fun2(void *arg)
{
int i = 0;
int value = 0;
while(i < 10000)
{
value = g_queue.get();
cout<<"thread2_get:"<<value<<endl;
i++;
}
}
void *pthr_fun3(void *arg)
{
int i = 0;
int value = 0;
while(i < 10000)
{
value = g_queue.get();
cout<<"thread3_get:"<<value<<endl;
i++;
}
}
void *pthr_fun4(void *arg)
{
int i = 0;
int value = 0;
while(i < 10000)
{
value = g_queue.get();
cout<<"thread4_get:"<<value<<endl;
i++;
}
}
int main () {
pthread_t thread1, thread2, thread3, thread4;
pthread_create(&thread1,NULL,pthr_fun1,NULL);\
pthread_create(&thread2,NULL,pthr_fun2,NULL);\
pthread_create(&thread3,NULL,pthr_fun3,NULL);\
pthread_create(&thread4,NULL,pthr_fun4,NULL);\

pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
pthread_join(thread3,NULL);
pthread_join(thread4,NULL);
return 0;
}