boost之对象池使用实例

这个主要用在http使用tcp支持短连接的情况，能快速获取连接对象而不用反复申请释放资源

#ifndef	OBJECT_POOL_H
#define	OBJECT_POOL_H

#include "boost_comm.h"

#include "message_header.h"
#include "tcp_client.h"

namespace seemmo
{
	//template
	class object_pool
	{
	public:
		object_pool();
		~object_pool();
	protected:
		static object_pool *instance()
		{
			static object_pool inst;
			return &inst;
		}		
	private:
		boost::mutex mtx2_;
	public:
		static boost::mutex * alloc_mutex();
		static void free_mutex(boost::mutex *src);

	private:
		boost::mutex mtx3_;
	public:
		static tcp_client* alloc_client();
		static void free_client(tcp_client *src);
	private:
		boost::mutex mtx4_;
	public:
		static result_data * alloc_data(string cardid, float score, string params[]);
		static void free_data(result_data *src);
	private:
		boost::mutex mtx5_;
	public:
		static ret_result *alloc_result(std::string code, std::string msg, int n = 100);
		static void free_result(ret_result *src);
	protected:
		boost::object_pool mtx_obp_;
		boost::object_pool obp_client_;
		boost::object_pool obp_data_;
		boost::object_pool obp_result_;
	private:
	};
}

#endif // OBJECT_POOL_H

#include "object_pool.h"

namespace seemmo
{
	object_pool::object_pool()
	{
	}

	object_pool::~object_pool()
	{
	}

	boost::mutex * object_pool::alloc_mutex()
	{
		boost::unique_lock wlock(instance()->mtx2_);
		return instance()->mtx_obp_.construct();
	}

	void object_pool::free_mutex(boost::mutex *src)
	{
		boost::unique_lock wlock(instance()->mtx2_);
		instance()->mtx_obp_.destroy(src);
	}

	tcp_client* object_pool::alloc_client()
	{
		boost::unique_lock wlock(instance()->mtx3_);
		return instance()->obp_client_.construct();
	}

	void object_pool::free_client(tcp_client *src)
	{
		boost::unique_lock wlock(instance()->mtx3_);
		instance()->obp_client_.destroy(src);
	}
	result_data * object_pool::alloc_data(string cardid, float score, string params[])
	{
		boost::unique_lock wlock(instance()->mtx4_);
		return instance()->obp_data_.construct(cardid, score, params);
	}

	void object_pool::free_data(result_data *src)
	{
		boost::unique_lock wlock(instance()->mtx4_);
		instance()->obp_data_.destroy(src);
	}

	ret_result *object_pool::alloc_result(std::string code, std::string msg, int n /* = 100 */)
	{
		boost::unique_lock wlock(instance()->mtx5_);
		return instance()->obp_result_.construct(code, msg, n);
	}

	void object_pool::free_result(ret_result *src)
	{
		boost::unique_lock wlock(instance()->mtx5_);
		instance()->obp_result_.destroy(src);
	}
}