cocos2dx多线程以及线程同步与cocos2dx内存管理与多线程问题

//-------------------------------------------------------------------- // // CCPoolManager // //-------------------------------------------------------------------- /////【diff - begin】- by layne////// CCPoolManager* CCPoolManager::shared

//--------------------------------------------------------------------

//

// CCPoolManager

//

//--------------------------------------------------------------------

/////【diff - begin】- by layne//////

CCPoolManager* CCPoolManager::sharedPoolManager()

{

if (s_pPoolManager == NULL)

{

s_pPoolManager = new CCPoolManager();

}

return s_pPoolManager;

}

void CCPoolManager::purgePoolManager()

{

CC_SAFE_DELETE(s_pPoolManager);

}

CCPoolManager::CCPoolManager()

{

// m_pReleasePoolStack = new CCArray();

// m_pReleasePoolStack->init();

// m_pCurReleasePool = 0;

m_pReleasePoolMultiStack = new CCDictionary();

}

CCPoolManager::~CCPoolManager()

{

// finalize();

// // we only release the last autorelease pool here

// m_pCurReleasePool = 0;

// m_pReleasePoolStack->removeObjectAtIndex(0);

//

// CC_SAFE_DELETE(m_pReleasePoolStack);

finalize();

CC_SAFE_DELETE(m_pReleasePoolMultiStack);

}

void CCPoolManager::finalize()

{

if(m_pReleasePoolMultiStack->count() > 0)

{

//CCAutoreleasePool* pReleasePool;

CCObject* pkey = NULL;

CCARRAY_FOREACH(m_pReleasePoolMultiStack->allKeys(), pkey)

{

if(!pkey)

break;

CCInteger *key = (CCInteger*)pkey;

CCArray *poolStack = (CCArray *)m_pReleasePoolMultiStack->objectForKey(key->getValue());

CCObject* pObj = NULL;

CCARRAY_FOREACH(poolStack, pObj)

{

if(!pObj)

break;

CCAutoreleasePool* pPool = (CCAutoreleasePool*)pObj;

pPool->clear();

}

}

}

}

void CCPoolManager::push()

{

// CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1

// m_pCurReleasePool = pPool;

//

// m_pReleasePoolStack->addObject(pPool); //ref = 2

//

// pPool->release(); //ref = 1

pthread_mutex_lock(&m_mutex);

CCArray* pCurReleasePoolStack = getCurReleasePoolStack();

CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1

pCurReleasePoolStack->addObject(pPool); //ref = 2

pPool->release(); //ref = 1

pthread_mutex_unlock(&m_mutex);

}

void CCPoolManager::pop()

{

// if (! m_pCurReleasePool)

// {

// return;

// }

//

// int nCount = m_pReleasePoolStack->count();

//

// m_pCurReleasePool->clear();

//

// if(nCount > 1)

// {

// m_pReleasePoolStack->removeObjectAtIndex(nCount-1);

//

// // if(nCount > 1)

// // {

// // m_pCurReleasePool = m_pReleasePoolStack->objectAtIndex(nCount - 2);

// // return;

// // }

// m_pCurReleasePool = (CCAutoreleasePool*)m_pReleasePoolStack->objectAtIndex(nCount - 2);

// }

//

// /*m_pCurReleasePool = NULL;*/

pthread_mutex_lock(&m_mutex);

CCArray* pCurReleasePoolStack = getCurReleasePoolStack();

CCAutoreleasePool* pCurReleasePool = getCurReleasePool();

if (pCurReleasePoolStack && pCurReleasePool)

{

int nCount = pCurReleasePoolStack->count();

pCurReleasePool->clear();

if(nCount > 1)

{

pCurReleasePoolStack->removeObject(pCurReleasePool);

}

}

pthread_mutex_unlock(&m_mutex);

}

void CCPoolManager::removeObject(CCObject* pObject)

{

// CCAssert(m_pCurReleasePool, "current auto release pool should not be null");

//

// m_pCurReleasePool->removeObject(pObject);

pthread_mutex_lock(&m_mutex);

CCAutoreleasePool* pCurReleasePool = getCurReleasePool();

CCAssert(pCurReleasePool, "current auto release pool should not be null");

pCurReleasePool->removeObject(pObject);

pthread_mutex_unlock(&m_mutex);

}

void CCPoolManager::addObject(CCObject* pObject)

{

// getCurReleasePool()->addObject(pObject);

pthread_mutex_lock(&m_mutex);

CCAutoreleasePool* pCurReleasePool = getCurReleasePool(true);

CCAssert(pCurReleasePool, "current auto release pool should not be null");

pCurReleasePool->addObject(pObject);

pthread_mutex_unlock(&m_mutex);

}

CCArray* CCPoolManager::getCurReleasePoolStack()

{

CCArray* pPoolStack = NULL;

pthread_t tid = pthread_self();

if(m_pReleasePoolMultiStack->count() > 0)

{

pPoolStack = (CCArray*)m_pReleasePoolMultiStack->objectForKey((int)tid);

}

if (!pPoolStack) {

pPoolStack = new CCArray();

m_pReleasePoolMultiStack->setObject(pPoolStack, (int)tid);

pPoolStack->release();

}

return pPoolStack;

}

CCAutoreleasePool* CCPoolManager::getCurReleasePool(bool autoCreate)

{

// if(!m_pCurReleasePool)

// {

// push();

// }

//

// CCAssert(m_pCurReleasePool, "current auto release pool should not be null");

//

// return m_pCurReleasePool;

CCAutoreleasePool* pReleasePool = NULL;

CCArray* pPoolStack = getCurReleasePoolStack();

if(pPoolStack->count() > 0)

{

pReleasePool = (CCAutoreleasePool*)pPoolStack->lastObject();

}

if (!pReleasePool && autoCreate) {

CCAutoreleasePool* pPool = new CCAutoreleasePool(); //ref = 1

pPoolStack->addObject(pPool); //ref = 2

pPool->release(); //ref = 1

pReleasePool = pPool;

}

return pReleasePool;

}

/////【diff - end】- by layne//////