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//////