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.youkuaiyun.com/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，如果此时工作线程正好拥有此互斥体的话，主线程就会堵塞，直到获取到，不过这一点时间相对于主线程加载图片的时间就小巫见大巫了