glib g_main_loop理解

最新推荐文章于 2025-11-09 14:30:39 发布
转载 最新推荐文章于 2025-11-09 14:30:39 发布 · 2.6w 阅读 · 42
文章标签：

#gtk #callback #dialog #socket #up #linux

本文介绍了Glib Mainloop的工作原理及其实现机制，包括mainloop的使用模式、关键组件及事件源接口等，并详细探讨了几种内置事件源的实现。

 http://soft.zdnet.com.cn/software_zone/2008/0214/735181.shtml

 

main loop使用模式大致如下：

loop = g_main_loop_new (NULL, TRUE);

g_main_loop_run (loop);

 

g_main_loop_new创建一个main loop对象，一个main loop对象只能被一个线程使用，但一个线程可以有多个main loop对象。在GTK+应用中，一个线程使用多个main loop的主要用途是实现模态对话框，它在gtk_dialog_run函数里创建一个新的main loop，通过该main loop分发消息，直到对话框关闭为止。

 

g_main_loop_run则是进入主循环，它会一直阻塞在这里，直到让它退出为止。有事件时，它就处理事件，没事件时就睡眠。

 

g_main_loop_quit则是用于退出主循环，相当于Win32下的PostQuitMessage函数。

 

Glib main loop的最大特点就是支持多事件源，使用非常方便。来自用户的键盘和鼠标事件、来自系统的定时事件和socket事件等等，还支持一个称为idle的事件源，其主要用途是实现异步事件。Main loop的基本组成如下图所示：

 

GMainLoop的主要部件是GMainContext，GMainContext可以在多个GMainLoop间共享，但要求这些GMainLoop都在同一个线程中运行，前面提到的模态对话框就属于这一类。GMainContext通常由多个GSource组成，GSource是事件源的抽象，任何事件源，只要实现GSource规定的接口，都可以挂到GMainContext中来。

 

GSource的接口函数有：

1.        gboolean (*prepare)  (GSource    *source, gint       *timeout_);进入睡眠之前，在g_main_context_prepare里，mainloop调用所有Source的prepare函数，计算最小的timeout时间，该时间决定下一次睡眠的时间。

2.        gboolean (*check)    (GSource    *source); poll被唤醒后，在g_main_context_check里，mainloop调用所有Source的check函数，检查是否有Source已经准备好了。如果poll是由于错误或者超时等原因唤醒的，就不必进行dispatch了。

3.        gboolean (*dispatch) (GSource*source, GSourceFunc callback,gpointer user_data);当有Source准备好了，在g_main_context_dispatch里，mainloop调用所有Source的dispatch函数，去分发消息。

4.        void     (*finalize) (GSource    *source);在Source被移出时，mainloop调用该函数去销毁Source。

 

Main loop的工作流程简图如下

 

下面我们看看几个内置Source的实现机制：

Idle它主要用实现异步事件，功能类似于Win32下的PostMessage。但它还支持重复执行的特性，根据用户注册的回调函数的返回值而定。

1.        g_idle_prepare把超时设置为0，也就是即时唤醒，不进入睡眠状态。

2.        g_idle_check始终返回TRUE，表示准备好了。

3.        g_idle_dispatch调用用户注册的回调函数。

 

Timeout它主要用于实现定时器，支持一次定时和重复定时，根据用户注册的回调函数的返回值而定。

1.        g_timeout_prepare计算下一次的超时时间。

2.        g_timeout_check检查超时时间是否到了，如果到了就返回TRUE，否则返回FALSE。

3.        g_timeout_dispatch调用用户注册的回调函数。

 

线程可以向自己的mainloop中增加Source，也可以向其它线程的mainloop增加Source。向自己的mainloop中增加Source时，mainloop已经唤醒了，所以不会存在什么问题。而向其它线程的mainloop增加Source时，对方线程可能正挂在poll里睡眠，所以要想法唤醒它，否则Source可能来不及处理。在Linux下，这是通过wake_up_pipe管道实现的，mainloop在poll时，它除了等待所有的Source外，还会等待wake_up_pipe管道。要唤醒poll，调用g_main_context_wakeup_unlocked向wake_up_pipe里写入字母A就行了。

 

 

Glib学习(2)——main loop
MoL的博客
08-01 2391
文章目录简介包含文件类型几个函数介绍GThreadFunc () 简介 主事件循环——管理所有可用的事件源 主事件循环管理GLib和GTK+应用程序的所有可用事件源。这些事件可以来自任意数量的不同类型的源，比如文件描述符(纯文件、管道或套接字)和超时。还可以使用g_source_attach()添加新类型的事件源。 为了允许在不同的线程中处理多个独立的源集，每个源都与一个GMainContext相关联。GMainContext只能在单个线程中运行，但是可以向其添加源，并从其他线程中删除源。所有在GMainC
g_main_loop_run 的简单使用举例
hjjdebug的专栏
04-23 1179
g_main_loop_run 的简单使用举例
嵌入式软件开发之------浅析 fork（）函数（十二）
lujian186的博客
02-14 850
linux代码版本：linux4.4 glibc代码版本：glibc-2.26 导读：在linux内核态也搞了好几年了，公司的新平台也都转向了用户态，发展趋势也是linux的工作量也来越少，更多的工作也将聚焦在业务上。其实无论是在内核态还是用户态编程，对于嵌入式编程来说，没有本质区别，嵌入式产品上也不太会去做数据库等之类的应用，大多还是基于设备文件操作、进程通信、socket等实现业务逻辑。在...
Python 模块的双面人生：`__name__`与`__main__`的奇妙之旅
最新发布
YAnt的博客
11-09 938
本文深入解析了Python中`__name__`和`__main__`的作用机制，通过生动比喻和实用示例展示了这一重要概念。从基础原理到高级应用，涵盖了模块双重身份管理的各个方面。文章提供了完整的实战案例和最佳实践，帮助读者编写更专业、可复用的Python代码。
Gstreamer中g_main_loop_new的使用
技术笔记
08-11 2843
这样的用大多数情况下都没有问题，比如自己创建的player，或者pipeline里面几乎都是这么用的。
glib main loop
ken_yjj的专栏
04-30 2648
从最简单的例子开始：//mainloop0.c#include GMainLoop* loop;int main(int argc, char* argv[]){    //g_thread_init是必需的，GMainLoop需要gthread库的支持。    if(g_thread_supported() == 0)        g_thread_init(NULL);    //创建一个循
glib学习笔记-1 2 main event loop 1 2
Linux Job
01-03 590
引用自： http://baicj.spaces.live.com/blog/cns!F60F8E193FAC08E4!410.entry http://baicj.spaces.live.com/blog/cns!F60F8E193FAC08E4!411.entry?wa=wsignin1.0&sa=837669587   按着glib的文档顺序，先来看看事件循环吧。 从最...
glib如何使用g_main_loop_new来创建主进程
06-09
`g_main_loop_new()` 函数可以用来创建一个新的主循环，主循环可以用于事件处理和异步任务的调度。下面是一个简单的示例程序，展示如何使用 `g_main_loop_new()` 函数创建一个主进程： ```c #include <glib.h> ...
详细介绍Glib 主事件循环轻度分析与编程应用
m0_73494896的博客
09-23 1817
glib是一个跨平台、用 C 语言编写的若干底层库的集合。编写案例最好能够结合 glib 源码，方便随时查看相关函数定义。glib实现了完整的事件循环分发机制。有一个主循环负责处理各种事件。事件通过事件源描述，常见的事件源文件描述符（文件、管道和 socket）超时idle 事件当然，也可以自定义事件源，通过 glib 提供的函数 g_source_attach() 就可以手动添加我们自定义的新类型事件源。可参考 [2.2](##2.2 案例2 glib 自定义事件源)
GLIB main event loop
小猪爱拱地
05-26 1263
下面是一个小程序，其实是一个简单的事件触发模型： #include #include #include GMainLoop *loop; gboolean callback(GIOChannel *channel) { gchar *str; gsize len; /*stdin*/ g_io_channel_read_line(channel, &st
GLib的主循环
Nova, Go!
01-18 1926
 GUI应用程序都是事件驱动的。这些事件大部分都来自于用户，比如键盘事件、鼠标事件或笔点事件。还有一些事件来自于系统内部，比如定时事件、socket事件和其它文件事件等等。在没有任何事件的情况下，应用程序处于睡眠状态。因为这种事件驱动机制，GUI应用程序都毫无例外的需要一个主循环(main loop)，主循环控制应用程序什么时候进入睡眠状态，什么时候被唤醒。Glib所提供的主循环便是GMa
glib g_main_loop的简单例子
Luobooooo的博客
12-07 4769
写了一个应用g_main_loop的简单例子 g_main_loop_new，创建了一个loop对象 g_main_loop_run，当程序运行到这里，就进入了一个死循环，不过添加到loop中的逻辑还是在跑的，必须要有g_main_loop_quit()才能终止循环 main_loop中，我们可以添加异步事件，用来执行回调函数，用到g_idle_add（） guint g_idle_ad...
七、GLib主要的事件循环（The Main Event Loop）
Creationyang的博客
09-23 2392
1 GMainLoop、GMainContext、GSource 1.1 三者之间关系 GMainLoop -> GMainContext -> {GSource1, GSource2,GSource3… } 每个GMainLoop都包含一个GMainContext成员，而这个GMainContext成员可以装各种各样的GSource，GSource则是具体的各种Event处理逻辑了。在这里，可以把GMainContext理解为GSource的容器，但是它的用处不只是装GSouce。 创建GM
GTK+主循环(main loop)的工作原理
热门推荐
国产开源 GUI 引擎 AWTK
03-17 1万+
GTK+主循环(main loop)的工作原理 转载时请注明出处和作者联系方式：http://blog.youkuaiyun.com/absurd作者联系方式：Li XianJing 更新时间：2007-3-17 我们知道GUI应用程序都是事件驱动的。这些事件大部分都来自于用户，比如键盘事件、鼠标事件或笔点事件。还有一些事件来自于系统内部，比如定时事件、socket事件和其它文件事件等
glib main loop 笔记
e28sean的专栏
12-13 1994
 从最简单的例子开始：//mainloop0.c#include GMainLoop* loop;int main(int argc, char* argv[]){    //g_thread_init是必需的，GMainLoop需要gthread库的支持。    if(g_thread_supported() == 0)        g_thread_init(NULL);    //创建一个
基于GLib Mainloop实现时间可变的Timeout Source
认真你就输了
09-19 1661
GLib的Timeout Source只能指定固定的时间间隔，因此，不适合做为精确计时使用（精度接近播放器的播放时间）。从2.36开始，GLib提供了一种方法，可以在不使用Timeout Source的情况下，使一个Source的Dispatch函数在指定的时间点被触发，从而提高计时精度。用法如下：1. 创建一个通用Source和Mainloopstatic GSourceFuncs ptimeF
Glib 主事件循环轻度分析与编程应用
个人笔记
05-17 3454
三个案例轻松搞定 glib 主事件循环
【glib】GMainLoop的实现原理和代码模型
EthanYYYY的博客
03-11 3647
本文主要通过Glib中的GMainloop介绍事件循环（event loop）
g_main_loop_new
08-20
<think>我们被要求提供关于`g_main_loop_new`的使用方法和示例。根据引用[1]中提供的信息，我们知道`GMainLoop`是GLib库中主事件循环的数据结构，通过`g_main_loop_new`创建。主事件循环用于处理多个事件源的事件，直到显式退出。 ### 函数原型 ```c GMainLoop * g_main_loop_new (GMainContext *context, gboolean is_running); ``` ### 参数说明 1. **`context`**: 一个`GMainContext`指针，表示事件循环的上下文。如果传入`NULL`，则使用默认的上下文。 2. **`is_running`**: 一个布尔值，表示创建后是否立即运行循环。通常设置为`FALSE`，然后通过`g_main_loop_run()`启动。 ### 返回值 返回一个指向`GMainLoop`的指针。 ### 基本使用步骤 1. **创建主循环对象**: 使用`g_main_loop_new()`创建。 2. **添加事件源**: 例如超时、IO监视器、空闲函数等（这里不展开，但示例中会包含一个超时事件）。 3. **运行主循环**: 调用`g_main_loop_run()`，该函数会阻塞直到调用`g_main_loop_quit()`退出循环。 4. **退出循环**: 在某个事件处理中调用`g_main_loop_quit()`。 5. **释放资源**: 使用`g_main_loop_unref()`减少引用计数，当引用计数为0时释放资源。 ### 示例代码 以下是一个简单的C语言示例，创建一个主循环，并添加一个超时事件，5秒后退出主循环。 ```c #include <glib.h> // 超时回调函数，返回TRUE表示持续调用，FALSE表示移除 static gboolean timeout_callback(gpointer data) { static int count = 0; g_print("超时回调被调用，count = %d\n", count++); // 5次后退出主循环 if (count >= 5) { g_main_loop_quit((GMainLoop *)data); return FALSE; // 移除超时源 } return TRUE; // 继续调用 } int main() { // 创建主循环，使用默认上下文 GMainLoop *loop = g_main_loop_new(NULL, FALSE); // 添加一个超时事件，每1秒触发一次 guint timeout_id = g_timeout_add_seconds(1, timeout_callback, loop); g_print("开始运行主事件循环...\n"); g_main_loop_run(loop); // 阻塞在这里，直到调用g_main_loop_quit g_print("主事件循环已退出。\n"); // 清理 g_source_remove(timeout_id); // 移除超时源（其实在回调中已经返回FALSE移除了，这里为了安全） g_main_loop_unref(loop); // 释放主循环 return 0; } ``` ### 代码说明 1. **创建主循环**：`g_main_loop_new(NULL, FALSE)`创建了一个使用默认上下文的主循环，创建后不立即运行。 2. **添加超时事件**：`g_timeout_add_seconds(1, timeout_callback, loop)`添加一个每秒触发一次的超时事件，回调函数为`timeout_callback`，并将主循环对象作为用户数据传入。 3. **运行主循环**：`g_main_loop_run(loop)`开始事件循环，此时程序会阻塞在这里，直到调用`g_main_loop_quit(loop)`。 4. **回调函数**：在回调函数中，当被调用5次后，调用`g_main_loop_quit(loop)`退出循环，并返回`FALSE`表示不再需要该超时事件（移除事件源）。 5. **清理**：退出循环后，我们移除超时源（虽然回调返回FALSE已经自动移除，但显式移除是良好实践）并释放主循环对象。 ### 编译 在Linux环境下，使用以下命令编译（需要安装glib库）： ```bash gcc main.c -o main `pkg-config --cflags --libs glib-2.0` ``` ### 注意事项 - 主循环是单线程的，所有的事件处理都在同一个线程中按顺序执行。 - 如果需要处理多线程，每个线程可以有自己独立的`GMainContext`和`GMainLoop`。 - 确保在退出循环后释放相关资源，避免内存泄漏。 ### 引用说明 以上内容参考了引用[1]中关于`GMainLoop`的基本描述，并提供了实际使用示例。 --- §§相关问题§§ 1. 如何在GLib主循环中处理多个事件源？ 2. `GMainContext`和`GMainLoop`之间的关系是什么？ 3. 在GLib中如何实现异步IO操作？</think># `g_main_loop_new` 函数详解与使用指南 `g_main_loop_new` 是 GLib 库中用于创建**主事件循环**的核心函数，它构成了 GTK 应用程序和 GLib 异步操作的基础架构。主事件循环负责处理应用程序的所有事件、信号和异步操作[^1]。 ## 函数原型与参数 ```c GMainLoop* g_main_loop_new( GMainContext *context, // 事件循环上下文 gboolean is_running // 是否立即运行 ); ``` ### 参数说明 1. **`context`**： - 事件循环的上下文对象 - 传入 `NULL` 表示使用默认上下文 - 多个事件循环可以共享同一个上下文 2. **`is_running`**： - 布尔值，控制是否在创建后立即运行 - `TRUE`：立即运行 - `FALSE`：需手动调用 `g_main_loop_run()` 启动 ### 返回值 - 成功时返回 `GMainLoop*` 指针 - 失败时返回 `NULL` ## 核心概念解析 ### 1. 主事件循环组件 ```mermaid graph LR A[GMainLoop] --> B[事件源] A --> C[事件分发] A --> D[信号处理] A --> E[异步操作] ``` ### 2. 事件处理流程 ```mermaid sequenceDiagram participant App as 应用程序 participant Loop as 主事件循环 participant Source as 事件源 App->>Loop: g_main_loop_new() App->>Loop: g_main_loop_run() loop 事件处理 Loop->>Source: 检查事件 Source-->>Loop: 新事件 Loop->>App: 触发回调 end App->>Loop: g_main_loop_quit() ``` ## 完整使用示例 ### 基础示例：创建并运行主循环 ```c #include <glib.h> // 超时回调函数 static gboolean timeout_callback(gpointer user_data) { static int count = 0; g_print("超时事件触发: %d\n", count++); // 5次后退出主循环 if (count >= 5) { g_main_loop_quit((GMainLoop*)user_data); return FALSE; // 停止此定时器 } return TRUE; // 继续定时器 } int main() { // 创建主循环（不立即运行） GMainLoop *loop = g_main_loop_new(NULL, FALSE); // 添加每秒触发的超时事件 g_timeout_add_seconds(1, timeout_callback, loop); g_print("启动主事件循环...\n"); g_main_loop_run(loop); // 阻塞直到调用quit g_print("主循环已退出\n"); // 释放资源 g_main_loop_unref(loop); return 0; } ``` ### 编译命令 ```bash gcc main.c -o main `pkg-config --cflags --libs glib-2.0` ``` ### 输出结果 ``` 启动主事件循环... 超时事件触发: 0 超时事件触发: 1 超时事件触发: 2 超时事件触发: 3 超时事件触发: 4 主循环已退出 ``` ## 高级用法 ### 1. 多线程事件循环 ```c // 工作线程函数 static gpointer worker_thread(gpointer data) { GMainLoop *loop = g_main_loop_new(NULL, FALSE); // 添加线程特定事件源... g_main_loop_run(loop); g_main_loop_unref(loop); return NULL; } int main() { // 创建主循环 GMainLoop *main_loop = g_main_loop_new(NULL, FALSE); // 创建工作线程 GThread *thread = g_thread_new("worker", worker_thread, NULL); // 运行主循环 g_main_loop_run(main_loop); // 清理 g_thread_join(thread); g_main_loop_unref(main_loop); } ``` ### 2. 自定义上下文 ```c // 创建独立上下文 GMainContext *context = g_main_context_new(); // 创建使用此上下文的主循环 GMainLoop *loop = g_main_loop_new(context, FALSE); // 在另一个线程处理事件 g_main_context_push_thread_default(context); // ... 添加事件源 ... // 运行循环 g_main_loop_run(loop); // 清理 g_main_loop_unref(loop); g_main_context_unref(context); ``` ## 关键API说明 1. **`g_main_loop_run(GMainLoop *loop)`**: - 启动事件循环 - 阻塞当前线程直到调用 `quit` 2. **`g_main_loop_quit(GMainLoop *loop)`**: - 退出事件循环 - 可在任何线程安全调用 3. **`g_main_loop_is_running(GMainLoop *loop)`**: - 检查循环是否正在运行 4. **`g_main_loop_ref/unref(GMainLoop *loop)`**: - 引用计数管理 ## 最佳实践 1. **资源管理**： ```c GMainLoop *loop = g_main_loop_new(NULL, FALSE); // 使用循环... g_main_loop_unref(loop); // 必须释放 ``` 2. **安全退出**： ```c // 在信号处理中安全退出 static void handle_signal(int sig) { g_main_loop_quit(global_loop); } ``` 3. **上下文选择**： - 单线程应用：使用默认上下文 (`NULL`) - 多线程应用：为每个线程创建独立上下文 4. **异步操作集成**： ```c // Python示例（参考引用[3]） async def run_command(): loop = asyncio._get_running_loop() # 在GLib事件循环中执行系统命令 await invoke_command_async("ping", loop=loop) ``` ## 常见问题解决 **Q: 主循环不退出怎么办？** A: 确保所有事件源都被正确移除，特别是返回 `TRUE` 的定时器。 **Q: 如何调试事件循环？** A: 设置环境变量 `G_MESSAGES_DEBUG=all` 查看详细事件日志。 **Q: 多线程下如何安全操作？** A: 使用 `g_main_context_invoke()` 跨线程安全调用函数。 ---
评论 7
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值