Cocos2d-x内存管理支持多线程修改autorelease

来源：互联网发布：mac远程连接服务器编辑：程序博客网时间：2024/06/08 14:33

最近使用Cocos2d-x开发游戏，发现Cocos2d-x的内存管理采用Objective-C的机制，大喜过望。因为只要坚持Objective-C的原则“谁创建谁释放，谁备份谁释放”的原则即可确保内存使用不易出现Bug。
但是因为本身开放的游戏需要使用到多线程技术，导致测试的时候总是莫名其妙的导致空指针错误。而且是随机出现，纠结了2天无果后，开始怀疑Cocos2d-X的内存本身管理可能存在问题。怀着这样的想法，
一步一步的调试，发现经常出现指针异常的变量总是在调用autorelease后一会就莫名其妙再使用的时候就抛异常。狠下心，在它的析构函数里面断点+Log输出信息。发现对象被释放了。一时也很迷糊，因为对象只是
autorelease,并没有真正释放，是谁导致它释放的？

然后就去看了CCAutoreleasePool的源码，发现存在Cocos2d-X的内存管理在多线程的情况下存在如下问题

如图：thread 1和thread 2是独立的两个线程，它们之间存在CPU分配的交叉集，我们在time 1的时候push一个autorelease的自动释放池，在该线程的末尾，即time 3的时候pop它。同理在thread 2的线程里面，在time 2的时候push一个自动释放池，在time 4的时候释放它，即Pop.
此时我们假设在thread 2分配得到CPU的时候有一个对象obj自动释放，即obj-autorelease().那么在time 3的时候会发生是么事情呢？
答案很简单，就是obj在time 3的时候就被释放了，而我们期望它在time 4的时候才释放。所以就导致我上面说的，在多线程下面，cocos2d-x的autorelease变量会发生莫名其妙的指针异常。

解决办法：在PoolManager给每个线程根据pthread_t的线程id生成一个CCArray的stack的嵌套管理自动释放池。源码如下
所以我在Push的时候根据当前线程的pthread_t的线程id生成一个CCArray的stack来存储该线程对应的Autoreleasepool的嵌套对象
源码如下

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
classCC_DLL CCPoolManager
{
    /////【diff - begin】- by layne//////
    //CCArray*    m_pReleasePoolStack;    
    //CCAutoreleasePool*                    m_pCurReleasePool;
     
    // CCAutoreleasePool* getCurReleasePool();
     
    CCDictionary* m_pReleasePoolMultiStack;
    pthread_mutex_t m_mutex;  // for multi-thread lock
     
    CCArray* getCurReleasePoolStack();
    CCAutoreleasePool* getCurReleasePool(boolautoCreate = false);
     
    /////【diff - end】- by layne////// 
     
public:
    CCPoolManager();
    ~CCPoolManager();
    voidfinalize();
    voidpush();
    voidpop();
 
    voidremoveObject(CCObject* pObject);
    voidaddObject(CCObject* pObject);
 
    staticCCPoolManager* sharedPoolManager();
    staticvoid purgePoolManager();
 
    friendclass CCAutoreleasePool;
};

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
//--------------------------------------------------------------------
//
// CCPoolManager
//
//--------------------------------------------------------------------
 
/////【diff - begin】- by layne//////
 
CCPoolManager* CCPoolManager::sharedPoolManager()
{
    if(s_pPoolManager == NULL)
    {
        s_pPoolManager = newCCPoolManager();
    }
    returns_pPoolManager;
}
 
voidCCPoolManager::purgePoolManager()
{
    CC_SAFE_DELETE(s_pPoolManager);
}
 
CCPoolManager::CCPoolManager()
{
    //    m_pReleasePoolStack = new CCArray();    
    //    m_pReleasePoolStack->init();
    //    m_pCurReleasePool = 0;
     
    m_pReleasePoolMultiStack = newCCDictionary();
}
 
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);
}
 
voidCCPoolManager::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();
            }
        }
    }
}
 
voidCCPoolManager::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 = newCCAutoreleasePool();         //ref = 1
    pCurReleasePoolStack->addObject(pPool);                              //ref = 2
    pPool->release();                                          //ref = 1    
     
    pthread_mutex_unlock(&m_mutex);
}
 
voidCCPoolManager::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)
    {
        intnCount = pCurReleasePoolStack->count();
         
        pCurReleasePool->clear();
         
        if(nCount > 1)
        {
            pCurReleasePoolStack->removeObject(pCurReleasePool);
        }
    }
     
    pthread_mutex_unlock(&m_mutex);
}
 
voidCCPoolManager::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);    
}
 
voidCCPoolManager::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 = newCCArray();
        m_pReleasePoolMultiStack->setObject(pPoolStack, (int)tid);
        pPoolStack->release();
    }
     
    returnpPoolStack;
}
 
CCAutoreleasePool* CCPoolManager::getCurReleasePool(boolautoCreate)
{
    //    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 = newCCAutoreleasePool();         //ref = 1
        pPoolStack->addObject(pPool);                              //ref = 2
        pPool->release();                                          //ref = 1
         
        pReleasePool = pPool;
    }
     
    returnpReleasePool;
}
 
/////【diff - end】- by layne////// 

Cocos2d-x内存管理支持多线程 修改autorelease

Cocos2d-x内存管理支持多线程修改autorelease