分析Cocos2d-x的主线程

最新推荐文章于 2021-05-29 15:54:16 发布

鱼儿-1226

最新推荐文章于 2021-05-29 15:54:16 发布

阅读量328

点赞数

分类专栏： cocos 文章标签： cocos2d

本文链接：https://blog.csdn.net/qq_21743659/article/details/108356744

版权

cocos 专栏收录该内容

217 篇文章 22 订阅

订阅专栏

Cocos2d-x目前仍然是一个单线程的游戏引擎，这使得我们几乎不需要考虑游戏对象更新的线程安全性。然而我们仍然需要关注一些情形如网络请求，异步加载文件，或者异步处理一些逻辑算法等等。分析Cocos2d-x的主线程

一、在主线程执行异步处理结果

有一些方法必须在主线程执行，例如GL相关的方法。另一些时候，为了保证如Ref对象引用计数的线程安全，我们也应该在主线程去执行这些操作。Scheduler提供了一种简单的机制，使可以在主线程上执行一个方法：

void Scheduler::performFunctionInCocosThread(const std::function &function)
{
    _performMutex.lock();
    _functionsToPerform.push_back(function);
    _performMutex.unlock();
}

首先向Scheduler注册一个方法指针，Scheduler存储一个需要在主线程执行的方法指针的数组，在当前帧所有系统或者自定义的schedule执行完之后，Scheduler就会检查该数组并执行其中的方法：

void Scheduler::update(float dt)
{
    if( !_functionsToPerform.empty() ) {
        _performMutex.lock();
        // fixed #4123: Save the callback functions, they must be invoked after ‘_performMutex.unlock()’, otherwise if new functions are added in callback, it will cause thread deadlock.
        auto temp = _functionsToPerform;
        _functionsToPerform.clear();
        _performMutex.unlock();
        for( const auto &function : temp ) {
            function();
        }
    }
}

通过这样的机制，我们就可以将一个方法转移到主线程执行。这里需要注意的是这些方法在主线程被执行的时机是所有系统或自定义的schedule之后，也即在UI树遍历之前。

二、文件异步加载完成

在上面的机制中，所有向Scheduler注册的方法都会在该帧结束的时候被全部执行，如果对于一些简单的算法，这没什么问题，如图左边的function列表。但是对于一些比较耗时的计算，为了不影响游戏的性能，我们需要把一系列耗时的方法分布在每一帧去执行。

Cocos2d-x纹理的异步加载完成之后，需要将纹理上传至GL内存中，因此这个传输的过程必须要在主线程执行。但是上传纹理的glTexImage2D命令是一个耗时的操作，试想如果有多个图片同时完成加载，这些纹理要在同一帧上传至GL内存中，这可能会使UI界面出现卡顿的现象，造成不好的用户体验。

因此，Cocos2d-x的纹理异步加载回调使用了一个自定义的schedule来处理，在该schedule内部，检查已经完成加载的纹理，每一帧处理一个纹理，直至所有纹理被处理完毕，则注销schedule。最后纹理在主线程执行的情况图右边的file列表：

TextureCache向Scheduler注册一个更新回调addImageAsyncCallBack：

void TextureCache::addImageAsyncCallBack(float dt)
{
    // the image is generated in loading thread
    std::deque *imagesQueue = _imageInfoQueue;

    _imageInfoMutex.lock();
    if (imagesQueue->empty())
    {
        _imageInfoMutex.unlock();
    }
    else
    {
        ImageInfo *imageInfo = imagesQueue->front();
        imagesQueue->pop_front();
        _imageInfoMutex.unlock();

        AsyncStruct *asyncStruct = imageInfo->asyncStruct;
        Image *image = imageInfo->image;

        const std::string& filename = asyncStruct->filename;

        Texture2D *texture = nullptr;
    if (image)
    {
        // generate texture in render thread
        texture = new Texture2D();

        texture->initWithImage(image);

        #if CC_ENABLE_CACHE_TEXTURE_DATA
        // cache the texture file name
        VolatileTextureMgr::addImageTexture(texture, filename);
        #endif
        // cache the texture. retain it, since it is added in the map
        _textures.insert( std::make_pair(filename, texture) );
        texture->retain();

        texture->autorelease();
    }
    else
    {
        auto it = _textures.find(asyncStruct->filename);
        if(it != _textures.end())
        texture = it->second;
    }

    asyncStruct->callback(texture);
    if(image)
    {
        image->release();
    }
    delete asyncStruct;
    delete imageInfo;

    –_asyncRefCount;
    if (0 == _asyncRefCount)
    {
        Director::getInstance()->getScheduler()->unschedule(schedule_selector(TextureCache::addImageAsyncCallBack), this);
    }
    }
}
在向TextureCache发起一个异步文件加载请求时，TextureCache会向Scheduler注册一个更新回调addImageAsyncCallback，然后开启一个新的线程异步加载文件。在新的线程中文件加载完毕时，将其纹理数据存储在_imageInfoQueue中，主线程每帧被更新回调时检查其是否有数据，如果有则将其纹理数据缓存到TextureCache中，并上传纹理至GL内存，然后删除_imageInfoQueue中的数据。最后，当所有文件都加载完毕，则注销更新回调。