cocos2dx-TextureCache::addImageAsync函数详解

这几天使用了cocos2dx后，对异步加载很感兴趣，所谓过异步加载，就是开启多线程进行资源的加载，同时因为cocos2dx的PoolManager(内存池)不是线程安全的，所以在工作线程中就得避免使用release() retain() autorelease()等函数。

因为现在的cocos2dx已经是3.x时代了，好些内容已经进行了改变，就比如异步加载资源，cocos2dx在 2.x使用的是pthread，是线程的POSIX标准。而在3.x就全部使用了c++11标准的<thread> <mutex>等标准库

先看看代码吧

void TextureCache::addImageAsync(const std::string &path, const std::function<void(Texture2D*)>& callback){    Texture2D *texture = nullptr;    //根据当前路径获取绝对路径    std::string fullpath = FileUtils::getInstance()->fullPathForFilename(path);    //当前是否存在该绝对路径所对应的texture    auto it = _textures.find(fullpath);    if( it != _textures.end() )        texture = it->second;    //如果存在，则尝试直接回调该函数    if (texture != nullptr)    {        if (callback) callback(texture);        return;    }    // 检测文件是否真的存在，如果不存在，尝试回调函数    if ( fullpath.empty() || ! FileUtils::getInstance()->isFileExist( fullpath ) ) {        if (callback) callback(nullptr);        return;    }    /*滞后赋值 创建一个工作线程，是c++11新增的，相对比较大的优点就是可以传递类的成员函数，第二个参数传递对象的指针*/      if (_loadingThread == nullptr)    {        // 创建一个新的线程来不停尝试加载图片资源        _loadingThread = new std::thread(&TextureCache::loadImage, this);        _needQuit = false;    }    //开始定时调度器，会在主线程中一直尝试作加载资源的收尾阶段，比如创建Texture2D，回调函数等    if (0 == _asyncRefCount)    {        Director::getInstance()->getScheduler()->schedule(CC_SCHEDULE_SELECTOR(TextureCache::addImageAsyncCallBack), this, 0, false);    }    //引用计数器加一    ++_asyncRefCount;    // 创建异步加载结构体，这个结构体内保存着资源路径，回调函数，异步加载完成的Image，以及loadSuccess，表示是否加载成功    AsyncStruct *data = new (std::nothrow) AsyncStruct(fullpath, callback);        // 增加这个异步结构体到队列中    _asyncStructQueue.push_back(data);    //std::mutex 互斥体，避免多线程同时访问    _requestMutex.lock();    _requestQueue.push_back(data);    _requestMutex.unlock();    //唤醒等待进程    _sleepCondition.notify_one();}

cocos2dx很巧妙地实现了异步加载。即cocos2dx维护了

_requestQueue 请求加载队列 由addImageAsync添加 在loadImage中进行移除

_responseQueue 加载完成队列 资源在loadImage中加载完成后，就会添加到此队列中 然后在addImageAsyncCallback函数中进行一些收尾工作

void TextureCache::loadImage(){    AsyncStruct *asyncStruct = nullptr;        std::mutex signalMutex;    std::unique_lock<std::mutex> signal(signalMutex);    while (!_needQuit)    {        // 从请求队列中移除一个加载结构体        _requestMutex.lock();        if(_requestQueue.empty())        {            asyncStruct = nullptr;        }else        {            asyncStruct = _requestQueue.front();            _requestQueue.pop_front();        }        _requestMutex.unlock();        //当前请求队列已经全部加载完毕，此线程阻塞直至被唤醒，这个在addImageAsync中会被唤醒        if (nullptr == asyncStruct) {            _sleepCondition.wait(signal);            continue;        }                // 加载image        asyncStruct->loadSuccess = asyncStruct->image.initWithImageFileThreadSafe(asyncStruct->filename);        // 把加载完成的结构体放在加载完成队列中        _responseMutex.lock();        _responseQueue.push_back(asyncStruct);        _responseMutex.unlock();    }}

这个函数主要负责异步加载资源，至于那个条件变量_sleepCondition，在http://blog.csdn.net/watson2016/article/details/52861094中这样说到，"当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。"

void TextureCache::addImageAsyncCallBack(float dt){    Texture2D *texture = nullptr;    AsyncStruct *asyncStruct = nullptr;    while (true)    {        // 从加载完成队列中移除一个结构体指针        _responseMutex.lock();        if(_responseQueue.empty())        {            asyncStruct = nullptr;        }else        {            asyncStruct = _responseQueue.front();            _responseQueue.pop_front();                        // 必须保证资源是按序加载            CC_ASSERT(asyncStruct == _asyncStructQueue.front());            _asyncStructQueue.pop_front();        }        _responseMutex.unlock();        //当前加载完成队列为空，直接退出这次循环        if (nullptr == asyncStruct) {            break;        }                // 再次进行一个检测        auto it = _textures.find(asyncStruct->filename);        if(it != _textures.end())        {            texture = it->second;        }        else        {            // 转换成Texture2D            if (asyncStruct->loadSuccess)            {                Image* image = &(asyncStruct->image);                // generate texture in render thread                texture = new (std::nothrow) Texture2D();                                texture->initWithImage(image);                //parse 9-patch info                //...略        }                // 尝试回调函数        if (asyncStruct->callback)        {            (asyncStruct->callback)(texture);        }        // 释放资源        delete asyncStruct;        --_asyncRefCount;    }    //当前没有请求加载的资源，取消这个函数的调用    if (0 == _asyncRefCount)    {        Director::getInstance()->getScheduler()->unschedule(CC_SCHEDULE_SELECTOR(TextureCache::addImageAsyncCallBack), this);    }}

如果加载完成队列非空，则一次性进行资源加载的后续处理。

使用异步加载也会对帧率造成影响，因为在addImageAsync内部需要获取互斥体_requestMutex，如果此时工作线程正好拥有此互斥体的话，主线程就会堵塞，直到获取到，不过这一点时间相对于主线程加载图片的时间就小巫见大巫了