apr_pool -- 内存池

apr_pool_cleanup_register(mp, ANY_CONTEXT_OF_YOUR_CODE, ANY_CALLBACK_OF_YOUR_CODE, apr_pool_cleanup_null);

一个简单的示例:

注意编译时候加上:

LIBS := -lactivemq-cpp -lvoltdbcpp -lpq

//============================================================================
// Name        : tt.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <boost/unordered_map.hpp>
#include <boost/threadpool.hpp>  

#include<apr_pools.h>

using namespace std;

class APRMemoryPool
{
public:
    APRMemoryPool();
	virtual ~APRMemoryPool();

public:
	static APRMemoryPool* get_instance();
    long init();
    long uninit();
    void* malloc(boost::thread::id threadid,size_t alloc_size);
	void free(boost::thread::id threadid);

protected:
	long alloc_new_pool(boost::thread::id threadid, apr_pool_t** new_alloc_pool);
	long release_unused_pool(apr_pool_t** release_pool);

private:
   apr_pool_t* root_pool;
   vector<apr_pool_t*> recycled_apr_pools;
   boost::unordered_map< boost::thread::id, apr_pool_t* > using_pools;
   boost::mutex pools_mutex_map;
   boost::mutex pools_mutex_vector;
};
APRMemoryPool gl_APRMemoryMgr;

APRMemoryPool* APRMemoryPool::get_instance(){
    return &gl_APRMemoryMgr;
}

APRMemoryPool::APRMemoryPool()
:root_pool(NULL){
}

APRMemoryPool::~APRMemoryPool(){
    uninit();
}

long APRMemoryPool::init(){
	apr_pool_initialize();
	apr_pool_create(&root_pool,NULL);
	return 0;
}

long APRMemoryPool::uninit(){
	apr_pool_destroy(root_pool);
	apr_pool_terminate();
	return 0;
}

void* APRMemoryPool::malloc(boost::thread::id threadid, size_t alloc_size){
    apr_pool_t *thread_memory_pool = NULL;
	{
		boost::unique_lock<boost::mutex> malloc_lock(pools_mutex_map);
		boost::unordered_map<boost::thread::id, apr_pool_t*>::iterator iter = using_pools.find(threadid);
		if(iter != using_pools.end()){
		    thread_memory_pool = iter->second;
			return apr_palloc(thread_memory_pool,alloc_size);
		}
		else
		{
			if(recycled_apr_pools.size()!=0){
			    thread_memory_pool = recycled_apr_pools.back();
				recycled_apr_pools.pop_back();
				using_pools.insert(make_pair(threadid,thread_memory_pool));
				return apr_palloc(thread_memory_pool,alloc_size);
			}else{
				apr_pool_create(&thread_memory_pool,root_pool);
				using_pools.insert(make_pair(threadid,thread_memory_pool));
				cout<<"apr pool create a new one..............."<<endl;
				return apr_palloc(thread_memory_pool,alloc_size);
			}

		}
	}
}

void APRMemoryPool::free(boost::thread::id threadid)
{
    apr_pool_t *release_pool = NULL;
    {
		boost::unique_lock<boost::mutex> free_lock(pools_mutex_map);
		boost::unordered_map<boost::thread::id,apr_pool_t*>::iterator iter = using_pools.find(threadid);
		if(iter != using_pools.end())
		{
	        release_pool = iter->second;
		    apr_pool_clear(release_pool);
	        using_pools.erase(threadid);
	        recycled_apr_pools.push_back(release_pool);
		}else{
		   cout<<"unexcepted error....."<<endl;
		}
	}
}

long APRMemoryPool::alloc_new_pool(boost::thread::id threadid, apr_pool_t** alloc_new_pool)
{
	return 0;
}

int main(int argc, char *argv[])
{
	APRMemoryPool::get_instance()->init();
	void *p=APRMemoryPool::get_instance()->malloc(boost::this_thread::get_id(),100);
	std::cout <<p <<std::endl;
	APRMemoryPool::get_instance()->init();
	return (0);
}