专栏首页逍遥剑客的游戏开发多线程调用的封装技巧

多线程调用的封装技巧

很多时候, 我们想把一项操作放入后台线程去执行, 可能是为了提高操作体验(UI表现的流畅), 或者是性能(充分利用多核的计算能力)等

为了方便, 我在这里先定义一个简化的线程模型:

  • 所有的操作都定义为命令(Command)
  • 后台线程监听一个命令队列, 如果有命令就执行, 没有就等待
  • 如果收到结束通知, 则结束该线程

比如我们有两种操作:

void PrintA()
{
    printf("thread[%x]: aaa\n", this_thread::get_id().hash());
}
void PrintB()
{
    printf("thread[%x]: bbb\n", this_thread::get_id().hash());
}

这两种操作会在后台线程去执行, 用代码表示如下:

enum CommandType
{
    CommandA,
    CommandB
};

atomic_int8_t IsOver = 0;
concurrent_queue<CommandType> CommandQueue;

void SendCommand(CommandType cmd)
{
    CommandQueue.push(cmd);
}

atomic_int8_t IsOver = 0;
concurrent_queue<CommandType> CommandQueue;

void CommandThreadProc()
{
    printf("thread[%x]: start\n", this_thread::get_id().hash());

    chrono::seconds time(1);
    CommandType command;
    while (IsOver == 0)
    {
        if (CommandQueue.try_pop(command))
        {
            switch (command)
            {
            case CommandA:
                PrintA();
                break;
            case CommandB:
                PrintB();
                break;
            }
        }
        this_thread::sleep_for(time);
    }

    printf("thread[%x]: end\n", this_thread::get_id().hash());
}

运行:

int _tmain(int argc, _TCHAR* argv[])
{
    printf("thread[%x]: start\n", this_thread::get_id().hash());

    thread t(CommandThreadProc);

    SendCommand(CommandA);
    SendCommand(CommandB);

    this_thread::sleep_for(chrono::seconds(10));
    IsOver = true;
    t.join();
    printf("thread[%x]: end\n", this_thread::get_id().hash());
    system("pause");
    return 0;
}

Nebula3中使用的就是类似这样的模型, 把各种参数封装成Command, 发到后台线程去执行, 然后写一堆的swith-case去判断是什么命令, 再执行相应的操作 这种方式的好处就是简单, 而且也把操作细节隐藏在内部线程里了, 不过从编码的角度来看, 相当烦琐

改进一下, 把操作定义在外部, 然后把Command进行抽象, 这样可以免掉很多的条件判断和重复性编码:

struct Command
{
    virtual void DoCommand() = 0;
};

atomic_int8_t IsOver = 0;
concurrent_queue<Command*> CommandQueue;

void SendCommand(Command* cmd)
{
    CommandQueue.push(cmd);
}

void CommandThreadProc()
{
    printf("thread[%x]: start\n", this_thread::get_id().hash());

    chrono::seconds time(1);
    Command* command = nullptr;
    while (IsOver == 0)
    {
        if (CommandQueue.try_pop(command))
        {
           command->DoCommand();
           delete command;
           command = nullptr;
        }
        this_thread::sleep_for(time);
    }

    printf("thread[%x]: end\n", this_thread::get_id().hash());
}

这样定义后只需要派生抽象Command就好, 增加新的操作后台线程的代码无需变动:

struct CommandA : public Command
{
    virtual void DoCommand() override
    {
        PrintA();
        printf("\t%s\n", __FUNCTION__);
    }
};

struct CommandB : public Command
{
    virtual void DoCommand() override
    {
        PrintB();
        printf("\t%s\n", __FUNCTION__);
    }
};

/****************main****************/
    SendCommand(new CommandA());
    SendCommand(new CommandB());
/************************************/

但是这样还要是重复去定义很多个Command的子类. 在学习WPF时, 发现他们可以直接使用Dispatcher.BeginInvoke把某个函数发到后台去执行, 后来想了想, 其实就是把函数封装成对象发过去了. C++借助成员函数指针什么的也可以实现类似的机制:

struct FunctionCommand : public Command
{
    function<void()> fun;
    FunctionCommand(function<void()> f) : fun(f) {}

    virtual void DoCommand() override
    {
        fun();
        printf("\t%s\n", __FUNCTION__);
    }
};

/****************main****************/
    SendCommand(new FunctionCommand(PrintA));
    SendCommand(new FunctionCommand(PrintB));
/************************************/

这个方案看起来已经挺完美了, 但是, 还是不够灵活, 因为如果是在现有代码上重构, 一样需要封装很多函数出来. 在阅读Unreal代码时发现, 里面用了几个很巧妙的宏, 可以把代码片段封装成对象, 这样就免去了定义函数的代码量. 简化一下代码就是这样:

#define SEND_COMMAND(TypeName, Code) \
    { \
        struct TypeName##Command : public Command \
        { \
            virtual void DoCommand() override \
            { \
                Code; \
                printf("\t%s\n", __FUNCTION__); \
            } \
        }; \
        SendCommand(new TypeName##Command()); \
    }

/****************main****************/
    SEND_COMMAND(Print,
    {
        PrintA();
    });
    SEND_COMMAND(Print,
    {
        PrintB();
    });
    SEND_COMMAND(Print,
    {
        PrintB();
        PrintA();
    });
/************************************/

可以看到宏参数可以是多行的, 所以一段代码可以当成宏的一个参数传入, 然后封装成对象, 真是让人想不到的办法!

完整的main函数和执行结果如下:

int _tmain(int argc, _TCHAR* argv[])
{
    printf("thread[%x]: start\n", this_thread::get_id().hash());

    thread t(CommandThreadProc);

    SendCommand(new CommandA());
    SendCommand(new CommandB());

    SendCommand(new FunctionCommand(PrintA));
    SendCommand(new FunctionCommand(PrintB));

    SEND_COMMAND(Print,
    {
        PrintA();
    });
    SEND_COMMAND(Print,
    {
        PrintB();
    });
    SEND_COMMAND(Print,
    {
        PrintB();
        PrintA();
    });

    this_thread::sleep_for(chrono::seconds(10));
    IsOver = true;
    t.join();
    printf("thread[%x]: end\n", this_thread::get_id().hash());
    system("pause");
	return 0;
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Nebula3学习笔记(8): 脚本系统

    逍遥剑客
  • GDC2015: Networking for Physics Programmers

    逍遥剑客
  • Nebula3绘制2D纹理

    逍遥剑客
  • 【独家】深扒Yann LeCun清华演讲中提到的深度学习与人工智能技术(PPT+视频)

    本文长度为3000字,建议阅读10分钟 本文为Yann LeCun在清华大学做的关于深度学习与人工智能技术的演讲梗概。 姚期智先生引言: 非常荣幸来给大家介...

    数据派THU
  • 深度学习_0_相关概念

    AlexNet:卷积,池化,归一化,在卷积,池化,全连接 与LeNet类似,只不过层数变多

    Dean0731
  • Golang不同类型比较

    在日常开发过程中难免会遇到各个类型的变量的比较以及运算操作,这里我们做了一些简单的汇总,希望能给各位同学在开发中带来帮助。

    孤烟
  • 设计模式:命令模式

     今天说一下命令模式 命令模式 将请求封装成对象,以便使用不同的请求、队列或者日志来参数化其它对象。命令模式也支持可撤销的操作。这样将“行为请求者”与“行为实现...

    lpxxn
  • Prometheus监控学习笔记之Prometheus监控简介

    Prometheus(普罗米修斯)是一个开源系统监控和警报工具,最初是在SoundCloud建立的。它是一个独立的开放源码项目,并且独立于任何公司。不同于传统的...

    Jetpropelledsnake21
  • [Taro学习笔记]开始原因

    作为一个后端开发者,最讨厌的就是前端的各种框架纷繁复杂。还有各个平台,如各种小程序,还有app平台还有桌面端。想想都觉得恐怖。

    用户2353021
  • 微服务之SpringCloud基础

    用户1112962

扫码关注云+社区

领取腾讯云代金券