内存池（节点分配）

#ifndef JYMEMORY_POOL_H_
#define JYMEMORY_POOL_H_


#include "JYChunk.h"
#include "JYMutex.h"
#include <iostream>
#include <vector>
#include <list>


using namespace std;




class JYMemoryPool
{
public:
JYMemoryPool(int pool_size);
~JYMemoryPool();
JYChunk* Alloc();
int Free(JYChunk* chunk);
public:
static JYMemoryPool* GetInstance();
private:
list<JYChunk*> m_memory_list;
int m_pool_size;
JYMutex m_mutex;
private:
static JYMemoryPool *g_pool;
};

#endif

#include "JYMemoryPool.h"


JYMemoryPool* JYMemoryPool::g_pool = NULL;


JYMemoryPool::JYMemoryPool(int pool_size)
{
m_mutex.Lock();
m_pool_size = pool_size;
for(int i=0; i<m_pool_size; i++)
{
JYChunk *chunk = new JYChunk(1024*10);
m_memory_list.push_back(chunk);
}
m_mutex.Unlock();
}


JYMemoryPool::~JYMemoryPool()
{
list<JYChunk*>(m_memory_list).swap(m_memory_list);
}


JYChunk* JYMemoryPool::Alloc()
{
m_mutex.Lock();
if(m_memory_list.size() <= 0)
{


m_mutex.Unlock();
return NULL;
}
JYChunk *chunk = m_memory_list.front();
if(chunk->Data()!=NULL && chunk->GetBlockSize()>=1024 && chunk->GetStatus() == idle)
{
m_mutex.Unlock();
m_memory_list.pop_front();
return chunk;
}
else
{
m_mutex.Unlock();
return NULL;
}
}


int JYMemoryPool::Free(JYChunk* chunk)
{
m_mutex.Lock();
if(m_memory_list.size()>= m_pool_size)
{
m_mutex.Unlock();
return -1;
}
else
{
m_memory_list.push_back(chunk);
m_mutex.Unlock();
return 0;
}
}


JYMemoryPool* JYMemoryPool::GetInstance()
{
if(g_pool == NULL)
{
g_pool = new JYMemoryPool(100);
}
return g_pool;
}

#include "JYMemoryPool.h"
#include <string.h>
#include <stdio.h>
#include <unistd.h>


void *test(void *s)
{
JYMemoryPool *pool = JYMemoryPool::GetInstance();
for(int i=0; i<20000; i++)
{
  JYChunk *chunk = pool->Alloc();
if(chunk)
{
char *buf = (char *)chunk->Data();

strcpy(buf, "222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222");
cout << buf << "\n"<< i <<endl;
pool->Free(chunk);
}
}
}
int main()
{
int i;
for(i=0; i<100; i++)
{
pthread_t tid;
pthread_create(&tid, NULL, test, NULL);
cout << "thread number is " << i << endl;
}
sleep(1000000);
}