运行多个并发GMainLoops

问题描述

GLib的是用户允许在多个线程同时运行多个 GMainLoop 实例，而每个线程中运行自己的实例？我发现是和否的回答所有的地方。我意识到，这个问题已经在这个论坛问过（2011年12月）。

不过，我能没有明显的问题，运行在同一时间两个 GMainLoop 实例。我的测试code是非常简单的：

1. 创建一个 GMainLoop 在的main（）


2. 创建默认情况下超时来源和使用主循环 g_timeout_add


3. 创建在main（）
系统GThread

4. 使用运行主循环 g_main_loop_run


5. [线程上下文]：创建使用上下文 g_main_context_new


6. [线程上下文]：设置上下文使用线程默认 g_main_context_push_thread_default


7. [线程上下文]：创建一个使用 g_main_loop_new 一个循环，并赋予它新的上下文


8. [线程上下文]：创建一个超时来源，它通过 g_source_attach 附加到新环境。


9. [THREAD_CONTEXT]：有线程调用 g_main_loop_run

这样做，我看到的工作就好了 GMainLoop 的两个实例。超时回调被正确调用，后来调用按预期g_main_loop_quit的工作。

所以，它看起来是不是有并发工作的多个 GMainLoop 实例的问题。但也许我只是还没有行使API不够充分掌握情况。是否有一个明确的答案？

此外，这里的实际测试code，如果有人关心一下：

 的#define THREAD_TIMEOUTS（20）
的#define MAIN_TIMEOUS（1）typedef结构timeout_struct
{
    INT I;
    INT最大;
    GMainLoop *循环;
    字符*名称;} TIMEOUT_STRUCT;gboolean timeout_callback（gpointer数据）
{
    TIMEOUT_STRUCT * psTimeout =（TIMEOUT_STRUCT *）的数据;    psTimeout- I标记++;    如果（psTimeout- I标记== psTimeout-＆GT;最大）
    {
        如果（psTimeout-＆GT;最大== THREAD_TIMEOUTS）
        {
            g_main_loop_quit（（GMainLoop *）psTimeout-＆GT;环）;
        }
        返回FALSE;
    }    返回TRUE;
}
无效* thread_function（void *的数据）
{
    GMainContext * ps_context;
    GMainLoop * ps_loop;
    GSource * ps_timer;
    TIMEOUT_STRUCT sTimeout;    ps_context = g_main_context_new（）;
    g_main_context_push_thread_default（ps_context）;    ps_loop = g_main_loop_new（ps_context，FALSE）;    sTimeout.i = 0;
    sTimeout.max = THREAD_TIMEOUTS;
    sTimeout.loop = ps_loop;
    sTimeout.name =线程;
    ps_timer = g_timeout_source_new_seconds（1）;
    g_source_set_callback（ps_timer，timeout_callback，＆放大器; sTimeout，NULL）;
    g_source_attach（ps_timer，ps_context）;    g_main_loop_run（ps_loop）;    g_main_loop_quit（（GMainLoop *）的数据）;    返回NULL;}
/ *
 *这个主引导一个线程，然后启动了GMainLoop。然后线程运行
 *一个GMainLoop。线程设置一个触发十倍和主集的计时器
 *计时器触发两次。线程退出，
 *然后其他主升
 *
 *
 * * /
诠释的main（）
{
    GThread * ps_thread;
    GMainLoop *循环;
    TIMEOUT_STRUCT sTimeout;    循环= g_main_loop_new（NULL，FALSE）;    sTimeout.i = 0;
    sTimeout.max = MAIN_TIMEOUS;
    sTimeout.loop =环路;
    sTimeout.name =主;    //添加源到默认的上下文
    g_timeout_add（1，timeout_callback，＆放大器; sTimeout）;    ps_thread = g_thread_new（线程，thread_function，循环）;    g_main_loop_run（环）;
    g_main_loop_unref（环）;
}
 

解决方案

这本书GTK +开发的基础这一状态：

So, given this, my test code, and the link I posted in the comment above we have a definitive answer to this question.

Namely: Multiple threads may have their own GMainContext & GMainLoop, and are able to independently run these loops in a concurrent fashion.

这篇关于运行多个并发GMainLoops的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！