服务器设计笔记(5)-----分享几个线程安全的容器

/*
* PipeList.h
*
*  Created on: Aug 28, 2012
*      Author: archy_yu
*/

#ifndef PIPELIST_H_
#define PIPELIST_H_

#include <list>

#include "Mutex.h"
#include "GameUtil.h"

template <class CObject>
class PipeList
{
friend class Player;
friend class EvenPlayer;
friend class ClientPlayer;
public:

PipeList(){}

virtual ~PipeList(){}

/**************************************************************
*
*be careful
*
* ***********************************************************/

int pop(CObject &_arg,BOOL swap = TRUE)
{
if(this->_read_list.empty())
{

if(swap == FALSE)
{
return -1;
}

Auto_Mutex _auto_mutex(this->_mutex);
if(!this->_write_list.empty())
{
this->_write_list.swap(this->_read_list);
}
else
{
return -1;
}
}
_arg = this->_read_list.front();
this->_read_list.pop_front();
return 0;
}

void push(CObject &_arg)
{
Auto_Mutex _auto_mutex(this->_mutex);
this->_write_list.push_back(_arg);
}

int Size()
{
return this->_list.size();
}

private:
void swap()
{
if(!this->_read_list.empty())
{
return;
}
Auto_Mutex _auto_mutex(this->_mutex);
this->_write_list.swap(this->_read_list);
}

private:

std::list<CObject> _write_list;

std::list<CObject> _read_list;

Mutex _mutex;

};

#endif /* DUPLEXLIST_H_ */

/*
* PipeList.h
*
*  Created on: Aug 28, 2012
*      Author: archy_yu
*/

#ifndef TSMAP_H_
#define TSMAP_H_

#include <map>
#include <ext/hash_map>

using namespace __gnu_cxx;

template <class Key,class CObject>
class TsMap
{
public:

TsMap(){}

virtual ~TsMap(){}

int find(Key key,CObject &_args)
{
Auto_R_Mutex _auto_mutex(this->_mutex);
if(this->_map.count(key) <= 0)
{
return -1;
}
_args = this->_map.find(key)->second ;
return 0;
}

int bind(Key key,CObject _args)
{
Auto_W_Mutex _auto_mutex(this->_mutex);
this->_map[key] = _args;
return 0;
}

int unbind(Key key)
{
Auto_W_Mutex _auto_mutex(this->_mutex);
this->_map.erase(key);
return 0;
}
int Size()
{
Auto_R_Mutex _auto_mutex(this->_mutex);
return this->_map.size();
}

private:

std::map<Key,CObject> _map;

RW_Mutex _mutex;
};

template <class Key,class CObject>
class TsHash_Map
{
public:

TsHash_Map(){}

virtual ~TsHash_Map(){}

int find(Key _key,CObject &_object)
{
Auto_R_Mutex _auto_mutex(this->_mutex);
if(this->_map.count(_key) <= 0)
{
return -1;
}
_object = this->_map.find(_key)->second;
return 0;
}

int bind(Key _key,CObject _object)
{
Auto_W_Mutex _aotu_mutex(this->_mutex);
this->_map[_key] = _object;
return 0;
}

int unbind(Key _key)
{
Auto_W_Mutex _auto_mutex(this->_mutex);
this->_map.erase(_key);
return 0;
}

int Size()
{
Auto_R_Mutex _auto_mutex(this->_mutex);
return this->_map.size();
}

private:
hash_map<Key,CObject> _map;
RW_Mutex _mutex;
};

#endif

class Auto_R_Mutex
{
public:
Auto_R_Mutex(RW_Mutex &rw_mutex);
virtual ~Auto_R_Mutex();
private:
Auto_R_Mutex();
RW_Mutex *_mutex;
};

class Auto_W_Mutex
{
public:
Auto_W_Mutex(RW_Mutex &rw_mutex);
virtual ~Auto_W_Mutex();
private:
Auto_W_Mutex();
RW_Mutex *_mutex;
};

Auto_Mutex::Auto_Mutex(Mutex &mutex)
{
this->_mutex = &mutex;
this->_mutex->lock();
}
Auto_Mutex::~Auto_Mutex()
{
this->_mutex->Release();
}

Auto_R_Mutex::Auto_R_Mutex(RW_Mutex &rw_mutex)
{
this->_mutex = &rw_mutex;
this->_mutex->rLock();
}
Auto_R_Mutex::~Auto_R_Mutex()
{
this->_mutex->rRelease();
}

Auto_W_Mutex::Auto_W_Mutex(RW_Mutex &rw_mutex)
{
this->_mutex = &rw_mutex;
this->_mutex->wLock();
}

Auto_W_Mutex::~Auto_W_Mutex()
{
this->_mutex->wRelease();
}

class RW_Mutex
{
public:

RW_Mutex();

virtual ~RW_Mutex();

int rLock();

int rRelease();

int wLock();

int wRelease();

private:

pthread_rwlock_t _map_lock;

};

class Mutex
{
public:
Mutex();

virtual ~Mutex();

int lock();

int Release();

private:
pthread_mutex_t _lock;
};

RW_Mutex::RW_Mutex()
{
pthread_rwlock_init(&_map_lock,NULL);
}

RW_Mutex::~RW_Mutex()
{
pthread_rwlock_destroy(&_map_lock);
}

int RW_Mutex::rLock()
{
pthread_rwlock_rdlock(&_map_lock);
return 0;
}

int RW_Mutex::rRelease()
{
pthread_rwlock_unlock(&_map_lock);
return 0;
}

int RW_Mutex::wLock()
{
pthread_rwlock_wrlock(&_map_lock);
return 0;
}

int RW_Mutex::wRelease()
{
pthread_rwlock_unlock(&_map_lock);
return 0;
}

Mutex::Mutex()
{
pthread_mutex_init(&this->_lock,NULL);
}

Mutex::~Mutex()
{
pthread_mutex_destroy(&this->_lock);
}

int Mutex::lock()
{
pthread_mutex_lock(&this->_lock);
return 0;
}

int Mutex::Release()
{
pthread_mutex_unlock(&this->_lock);
return 0;
}