详细介绍Glib 主事件循环轻度分析与编程应用

于 2023-06-17 16:56:15 发布
阅读量177 收藏 1
点赞数
分类专栏： linux c++ 文章标签： c++ linux
原文链接：https://zhuanlan.zhihu.com/p/567441726
版权
linux 同时被 2 个专栏收录
91 篇文章 6 订阅
订阅专栏
c++
24 篇文章 3 订阅
订阅专栏

1 glib 事件循环概述

glib 是一个跨平台、用 C 语言编写的若干底层库的集合。编写案例最好能够结合 glib 源码，方便随时查看相关函数定义。glib 实现了完整的事件循环分发机制。有一个主循环负责处理各种事件。事件通过事件源描述，常见的事件源

  • 文件描述符（文件、管道和 socket）
  • 超时
  • idle 事件

当然，也可以自定义事件源，通过 glib 提供的函数 g_source_attach() 就可以手动添加我们自定义的新类型事件源。可参考 [2.2](##2.2 案例2 glib 自定义事件源)

事件源默认会被分配一个优先级，默认为 G_PRIORITY_DEFAULT(200)，数字越小，优先级越高。当然也可以在添加空闲函数（g_idle_add_full）的时候，指定该事件源的优先级。具体应用还是结合后面的示例以及源码动手实践。

1.1 glib 主事件循环涉及的重要数据结构

GMainContext

为了让多组独立事件源能够在不同的线程中被处理，每个事件源都会关联一个GMainContext。一个线程只能运行一个GMainContext，但是在其他线程中能够对事件源进行添加和删除操作。GMainContext定义如下

/**
 * GMainContext:
 *
 * The `GMainContext` struct is an opaque data
 * type representing a set of sources to be handled in a main loop.
 */
typedef struct _GMainContext            GMainContext;

GMainLoop

GMainLoop 数据类型代表了一个主事件循环。通过g_main_loop_new()来创建GMainLoop对象。在添加完初始事件源后执行g_main_loop_run()，主循环将持续不断的检查每个事件源产生的新事件，然后分发它们，直到处理来自某个事件源的事件的时候触发了g_main_loop_quit()调用退出主循环为止。

struct _GMainLoop
{
  GMainContext *context;
  gboolean is_running; /* (atomic) */
  gint ref_count;  /* (atomic) */
};

1.2 glib / glibc /libc 傻傻分不清楚

  • glibc 和 libc 都是Linux 下的 C 函数库

libc 是 Linux 下的 ANSI C 函数库

glibc 是 Linux 下的 GUN C 函数库

glib 是 GTK+ 的基础库，一个综合用途的实用的轻量级的C程序库，与 glibc 没有实际联系

ANSI C 函数库是基本的 C 语言函数库，包含了 C 语言最基本的库函数。GNU C 函数库是一种类似于第三方插件的东西。由于 Linux 是用 C 语言写的，所以 Linux 的一些操作是用 C 语言实现的，因此，GUN 组织开发了一个 C 语言的库 以便让我们更好的利用 C 语言开发基于 Linux 操作系统的程序。

如今，glibc是 linux 下面 c 标准库的实现，即 GNU C Library，所以，我们在 Linux 用户态编程中最常用的库，libc.so，其实就是 glibc。

可能有人会认为，glib 前面有个 “g” ，所以认为 glib 是 GNU 的东西；同时认为 glibc 是 glib 的一个子集。 其实，glib 和 glibc 基本上没有太大联系，可能唯一的共同点就是，其都是 C 编程需要调用的库而已。

glib是GTK+的基础库，它由基础类型、对核心应用的支持、实用功能、数据类型和对象系统五个部分组成，可以在[The GTK Project - A free and open-source cross-platform widget toolkit gtk网站]下载其源代码。是一个综合用途的实用的轻量级的C程序库，它提供C语言的常用的数据结构的定义、相关的处理函数，有趣而实用的宏，可移植的封装和一些运行时机能，如事件循环、线程、动态调用、对象系统等的API。GTK+是可移植的，当然glib也是可移植的，你可以在linux下，也可以在windows下使用它。使用gLib2.0（glib的2.0版本）编写的应用程序，在编译时应该在编译命令中加入pkg-config --cflags --libs glib-2.0

2 三个案例轻松搞定 glib 事件循环

项目源码：https://github.com/liyansong2018/glib_demo

2.1 案例1 g_main_loop 基础用法

此案例中，我们一共添加了 3 个事件，包括 2 个超时事件源，一个空闲函数。主循环g_main_loop_run不停地检查是否有新事件发生。**各个事件源处理函数，如果返回值为 FALSE，则该事件源会被删除。如果返回值为 TRUE，则事件源一直存在。**具体含义请看如下代码

/* test.c */
int main(int argc, char const *argv[]) {
    /* 1.创建一个 GMainLoop 结构体对象，作为一个主事件循环 */
    GMainLoop *loop = g_main_loop_new(NULL, FALSE);

    /* 2.添加超时事件源 */
    g_timeout_add(1000, count_down, NULL);
    g_timeout_add(8000, cancel_fire, loop);

    /* 3.添加空闲函数，没有更高优先级事件时，空闲函数就可以被执行 */
    g_idle_add(say_idle, NULL);

    /* 4.循环检查事件源中是否有新事件进行分发，当某事件处理函数调用 g_main_loop_quit()，函数退出 */
    g_main_loop_run(loop);

    /* 5.减少loop引用计数，如果计数为0，则会释放loop资源 */
    g_main_loop_unref(loop);

    return 0;
}

每个事件函数的定义如下

/* 
 * FALSE，该事件源将被删除
 * TRUE，该事件源会在没有更高优先级事件时，再次运行
 */
gboolean count_down(gpointer data) {
    static int count = 10;

    if (count < 1) {
        printf(">>> count_down() return FALSE\n");
        return FALSE;
    }

    printf(">>> count_down() %4d\n", count--);
    return TRUE;
}

gboolean cancel_fire(gpointer data) {
    GMainLoop *loop = data;
    printf(">>> cancel_fire() quit \n");
    g_main_loop_quit(loop);

    return FALSE;
}

gboolean say_idle(gpointer data) {
    printf(">>> say_idle() idle \n");
    return TRUE;
}

编译

gcc $(pkg-config --cflags glib-2.0) test.c $(pkg-config --libs glib-2.0) -o test

或者使用 Makefile

运行结果如下

>>> say_idle() idle 
>>> count_down()   10
>>> count_down()    9
>>> count_down()    8
>>> count_down()    7
>>> count_down()    6
>>> count_down()    5
>>> count_down()    4
>>> cancel_fire() quit

 

结果分析

  • 本例中，没有更高优先级的事件，所以首先会运行空闲事件源，空闲函数返回 FALSE，该事件源被删除
  • 接着运行超时事件源，两个超时函数同时处理，count_down 1秒运行一次，cancel_fire 8 秒运行一次

2.2 案例2 glib 自定义事件源

使用函数 g_source_new创建 GSource类型对象，这个对象可以理解为我们自定义事件源。自定义事件源需要完成以下函数的定义

事件循环中的关键函数

  • prepare：调用每个事件源的 prepare 回调函数，检查事件源是否有事件发生。事件源分为两类：1、不需要 poll（idle 事件源），返回值 TRUE，表示 idle 事件已经发生；2、需要 poll（文件事件源），返回值 FALSE，因为只有轮询文件之后，才能知道文件事件是否发生。
  • query：获取需要 poll 的文件 fd
  • check：检查事件源是否有事件发生
  • dispatch：若某个特定事件源有事件发生（通常是 prepare/check返回 TRUE），则调用事件处理函数

入口函数如下：

int main(int argc, char const *argv[]) {
    GMainLoop *loop = g_main_loop_new(NULL, FALSE);
    GMainContext *context = g_main_loop_get_context(loop);

    GSourceFuncs g_source_myidle_funcs = {
        g_source_myidle_prepare,
        g_source_myidle_check,
        g_source_myidle_dispatch,
        g_source_myidle_finalize,
    };

    /* 创建新事件源实例，传入了事件的函数表、事件结构体大小 */
    GSource *source = g_source_new(&g_source_myidle_funcs, sizeof(GSourceMyIdle));
    /* 设置新事件源source的回调函数 */
    g_source_set_callback(source, (GSourceFunc)myidle, "Hello, world!", NULL);
    /* source关联特定的GMainContext对象 */
    g_source_attach(source, context);
    g_source_unref(source);

    g_main_loop_run(loop);

    g_main_context_unref(context);
    g_main_loop_unref(loop);

    return 0;
}

各个函数的定义如下：

/* 检查事件源是否有事件发生，如果有事件已经发生，则无需轮询（poll） */
gboolean g_source_myidle_prepare(GSource *source, gint *timeout) {
    *timeout = 0;
    return TRUE;
}

/* 检查事件源是否有事件发生 */
gboolean g_source_myidle_check(GSource *source) {
    return TRUE;
}

/* 分发事件源的事件=>调用事件源的回调函数 */
gboolean g_source_myidle_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) {
    gboolean again;

    /* g_source_set_callback未设置 */
    if (!callback) {
        g_warning("no callback");
        return FALSE;
    }

    again = callback(user_data);

    return again;
}

/* source被销毁前调用，使用此函数释放资源 */
gboolean g_source_myidle_finalize(GSource *source) {
    return FALSE;
}

gboolean myidle(gchar *message) {
    g_print("%s\n", message);

    /*  
     * G_SOURCE_REMOVE, 删除事件源
     * G_SOURCE_CONTINUE, 保留事件源
     */
    return G_SOURCE_REMOVE;
}

运行结果

Hello, world!

 

2.3 案例3 g_main_loop 自定义事件源

这里再介绍一个更加贴切实际的案例，这个案例中，我们启动一个 TCP Server

 netcat -l 127.0.0.1 8888

我们的目标是使用 glib 事件循环，编写一个 socket 客户端，定义一个 Echo 事件源，接受 TCP Server 的数据。代码 fork 自 KernelNewbies 微信公众号提供的 glib_demo

#include <stdio.h>
#include <glib.h>

#include <arpa/inet.h>
#include <sys/socket.h>

/* GSourceEcho */
typedef struct GSourceEcho {
	GSource source;
	GIOChannel *channel;
	GPollFD fd;
} GSourceEcho;

gboolean g_source_echo_prepare(GSource * source, gint * timeout);
gboolean g_source_echo_check(GSource * source);
gboolean g_source_echo_dispatch(GSource * source,
				GSourceFunc callback, gpointer user_data);
void g_source_echo_finalize(GSource * source);

gboolean echo(GIOChannel * channel);

/* tcp client */
int client_fd;

int client(void);

int main(int argc, char *argv[])
{
	if (-1 == client()) {
		g_print("%s\n", "start client error");

		return -1;
	}

	GMainLoop *loop = g_main_loop_new(NULL, FALSE);
	GMainContext *context = g_main_loop_get_context(loop);

	GSourceFuncs g_source_echo_funcs = {
		g_source_echo_prepare,
		g_source_echo_check,
		g_source_echo_dispatch,
		g_source_echo_finalize,
	};

	GSource *source =
	    g_source_new(&g_source_echo_funcs, sizeof(GSourceEcho));
	GSourceEcho *source_echo = (GSourceEcho *) source;

	source_echo->channel = g_io_channel_unix_new(client_fd);
	source_echo->fd.fd = client_fd;
	source_echo->fd.events = G_IO_IN;
	g_source_add_poll(source, &source_echo->fd);

	g_source_set_callback(source, (GSourceFunc) echo, NULL, NULL);

	g_source_attach(source, context);
	g_source_unref(source);

	g_main_loop_run(loop);

	g_main_context_unref(context);
	g_main_loop_unref(loop);

	return 0;
}

/* 对于文件描述符源，prepare 通常返回 FALSE，
 * 因为它必须等调用 poll 后才能知道是否需要处理事件
 *
 * 返回的超时为 -1，表示它不介意 poll 调用阻塞多长时间
*/
gboolean g_source_echo_prepare(GSource * source, gint * timeout)
{
	*timeout = -1;

	return FALSE;
}

/* 测试 poll 调用的结果，以查看事件是否发生
 */
gboolean g_source_echo_check(GSource * source)
{
	GSourceEcho *source_echo = (GSourceEcho *) source;

	/* events 为要监听的事件
	 * revents 为 poll 监听到的事件
	 *
	 * 因为只监听了一个事件，因此简化了比较方式
	 */
	if (source_echo->fd.revents != source_echo->fd.events) {
		return FALSE;
	}

	return TRUE;
}

gboolean g_source_echo_dispatch(GSource * source,
				GSourceFunc callback, gpointer user_data)
{
	gboolean again = G_SOURCE_REMOVE;

	GSourceEcho *source_echo = (GSourceEcho *) source;

	if (callback) {
		again = callback(source_echo->channel);
	}

	return again;
}

/* 释放 source 持有的资源的应用计数
 * 然后 source 才可以被安全地销毁，不会造成内存泄露
 */
void g_source_echo_finalize(GSource * source)
{
	GSourceEcho *source_echo = (GSourceEcho *) source;

	if (source_echo->channel) {
		g_io_channel_unref(source_echo->channel);
	}
}

gboolean echo(GIOChannel * channel)
{
	gsize len = 0;
	gchar *buf = NULL;

	g_io_channel_read_line(channel, &buf, &len, NULL, NULL);

	if (len > 0) {
		g_print("%s", buf);
		g_io_channel_write_chars(channel, buf, len, NULL, NULL);
		g_io_channel_flush(channel, NULL);
	}

	g_free(buf);

	return TRUE;
}

int client(void)
{
	struct sockaddr_in serv_addr;

	if (-1 == (client_fd = socket(AF_INET, SOCK_STREAM, 0))) {
		return -1;
	}

	memset(&serv_addr, 0, sizeof serv_addr);
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	serv_addr.sin_port = htons(9999);

	if (-1 ==
	    connect(client_fd, (struct sockaddr *) &serv_addr,
		    sizeof serv_addr)) {
		return -1;
	}

	return 0;
}

3 总结

glib 提供的事件循环机制非常实用，如 GNOME、QEMU 就使用了 glib 事件循环。本文只是轻度分析和使用了其提供的 API。更多深入的用法，其实只要结合一些开源项目，或者直接查看 glib 的源码，就可以了。

 

赵民勇
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gpotato:基于GLib的PEP 3156事件循环
05-11
gpotato-基于GLib的PEP 3156事件循环 Gpotato是一个python库，为实现接口。 它旨在与一起使用。 该代码需要进行彻底的测试，目前应该认为它是不稳定的。 这是一个分支。 执照 阿帕奇2.0 主页 要求 python3.4或...
Glib 主事件循环轻度分析与编程应用
个人笔记
05-17 2557
三个案例轻松搞定 glib 主事件循环
glib主事件循环
weixin_42834523的博客
06-30 971
glib 主事件循环
GMainLoop, GMainContext和GSource学习笔记
铁匠Smith先生的专栏
06-07 8312
做过GUI开发相关工作的人的人都知道，很多应用程序都是事件驱动的。这些事件大部分都来自于用户，比如键盘事件、鼠标事件或遥控器事件。还有一些事件来自于系统内部，比如定时事件、socket事件和其它文件事件等等。在没有任何事件的情况下，应用程序处于睡眠状态。     因为这种事件驱动机制，GUI应用程序都毫无例外的需要一个主循环(main loop)。主循环(main loop)控制应用程序什么
GLib核心应用支持
程序猿视角
07-22 523
主事件循环-管理所有可用的事件源 线程-对线程、互斥锁、锁、条件和线程私有数据的可移植支持 线程池—并发执行工作的线程池 异步队列-线程之间的异步通信 模块动态加载.动态加载“插件”的便携式方法 内存分配-常规内存处理 内存片—分配大小相等的内存块组的有效方法 IO通道-使用文件、管道和套接字的便携式支持 错误报告-报告错误的系统 警告和断言 消息输出和调试函数-用于输出消息和帮助调试应用程序的函数 ...
U8glib编程库
10-12
oled12864驱动,U8glib,12864液晶屏幕编程库。
浅谈Windows系统下C语言编程中Glib库的使用
09-02
主要介绍了Windows系统下C语言编程中Glib库的使用,Glib库在多线程编程中经常可以用到,需要的朋友可以参考下
C事件驱动循环的网络IO编程框架的源码.rar
07-09
基于事件驱动循环的网络IO编程框架，小编英语学的不好，直接把英原文复制出来，如下： Some of the specialties of libev not commonly found elsewhere are: - extensive and detailed, readable documentation ...
glib--消息分发（gmainloop，gsource），信号
evsqiezi
09-12 4975
每一个管道默认包含一个总线，所以应用程序不需要再创建总线。 应用程序只需要在总线上设置一个类似于对象的信号处理器的消息处理器。 当主循环运行的时候，总线将会轮询这个消息处理器是否有新的消息，当消息被采集到后，总线将呼叫相应的回调函数来完成任务。  GLib对核心应用的支持包括事件循环、内存操作、线程操作、动态链接库的操作和出错处理与日志等。基本上，所有需要异步操作的地方都可以用事件循环。像文件、...
七、GLib主要的事件循环（The Main Event Loop）
Creationyang的博客
09-23 1493
1 GMainLoop、GMainContext、GSource 1.1 三者之间关系 GMainLoop -> GMainContext -> {GSource1, GSource2,GSource3… } 每个GMainLoop都包含一个GMainContext成员，而这个GMainContext成员可以装各种各样的GSource，GSource则是具体的各种Event处理逻辑了。在这里，可以把GMainContext理解为GSource的容器，但是它的用处不只是装GSouce。 创建GM
linux - glib使用
qq_25439881的博客
12-15 3110
glib命令行参数解析 命令行参数解析 #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <math.h> #include <glib.h> #include <glib/gstdio.h> #include <fcntl.h> #include <sys/types.h>
GTK+图形化应用程序开发学习笔记（二）—Glib库
亭子的专栏
06-30 619
<br />在学习GTK+之前我们需要先学习一下 glib的有关知识。因为我们将会在以后的学习中遇到这些知识。由于本笔记不是专门介绍glib的，所以下面的介绍不会太详细。<br /><br /> 一、什么是glib库<br />        <br /> glib库是linux平台下最常用的c语言函数库，它具有很好的可移植性和实用性。glib是gtk+库和gnome的基础。glib的各种实用程序具 有一致的接口。glib为许多标准的、常用的C语言结构提供了相应的替代物。它的编码风格是半面向对象，标
浅析GLib
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
01-26 1743
浅析GLib内容：基础类型对核心应用的支持实用功能数据类型参考资料关于作者相关内容：GTK+2.0 中的容器控件与布局技巧应用GTK+编程在
编译-glib交叉编译
热门推荐
ty的专栏
07-18 1万+
glib是一个C语言函数库，它对很多系统调用进行了封装，提供了很多实用的功能，能极大地方便编程。 为了在产品上尝试使用glib，需要对glib进行交叉编译，使其能在ARM9上运行。但编译中间会碰到很多错误，需要耐心地逐一解决。
Glib事件源
finding的专栏
10-14 6715
http://club.cqvip.com/showtopic-666157-6.aspx 从文章中摘出来一些，然后自己整理了一下。 GLib 实现了一个功能强大的事件循环分发处理机制，GLib 内部实现了三种类型的事件源，分别是 Timeout, Idle, Child W
GMainLoop, GMainContext和GSource
Hu_yilang的博客
03-12 524
转载：https://blog.csdn.net/acs713/article/details/7641592 1.关系：GMainLoop -&gt; GMainContext -&gt; {GSource1, GSource2, GSource3......}-&gt;watch(iOChannel) 创建GMainLoop使用函数g_main_loop_new, 它的第一个参数就是需要关...
5_07_GLib库入门与实践_主循环
field1003的博客
03-13 991
简介 GLib主循环用来处理GLib和GTK+应用程序的所有事件源。GTK+的事件驱动特性正是基于GLib主循环。 GLib主循环设计思想是基于poll的"prepare/check/dispatch"模式，支持多事件源，像键盘、鼠标、文件、管道、设备、套接字、定时器及其他自定义事件类型对象都可以产生事件，这些事件可以作为事件源增加到主循环被统一管理。当产生事件时，主循环会调用事件源处理函数处理该事件。 GLib主循环模块内置了Idle和Timeout两个事件源。Idle主要实现异步事件，支持重复执行，当用
Glib学习笔记(2)
Innost的专栏
04-06 1万+
2.1 MainLoopmain loop是Glib中一个非常重要的部分，其主要用途类似于Windows的消息循环。所以它是一个循环，不停得从某个地方取得“消息”，然后派发到消息处理函数，交给他们处理。从执行者角度看，派发到消息处理函数实际还是消息循环所在的线程调用对应的函数。在Glib中，消息循环对应的就是这个mainLoop。消息队列没有对应物。但是消息的产地由GSourc
glib中主进程和主循环的差别？
最新发布
06-09
主循环是程序中主要的事件循环，在GLib中也被称为"Main Loop"。它是一个无限循环，负责监听系统事件、处理用户输入和其他事件，并通过调用回调函数来响应这些事件。主循环不断地从事件队列中取出事件并处理，直到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值