Chinaunix首页 | 论坛 | 博客
  • 博客访问: 663018
  • 博文数量: 109
  • 博客积分: 6081
  • 博客等级: 准将
  • 技术积分: 1318
  • 用 户 组: 普通用户
  • 注册时间: 2009-10-24 10:28
文章分类
文章存档

2011年(8)

2010年(39)

2009年(62)

分类: C/C++

2010-06-08 23:26:59

 

  1. //mainloop0.c   
  2. #include    
  3. GMainLoop* loop;   
  4. int main(int argc, char* argv[])   
  5. {   
  6.     //g_thread_init是必需的,GMainLoop需要gthread库的支持。   
  7.     if(g_thread_supported() == 0)   
  8.         g_thread_init(NULL);   
  9.     //创建一个循环体,先不管参数的意思。   
  10.     g_print("g_main_loop_new\n");   
  11.     loop = g_main_loop_new(NULL, FALSE);   
  12.     //让这个循环体跑起来   
  13.     g_print("g_main_loop_run\n");   
  14.     g_main_loop_run(loop);   
  15.     //循环运行完成后,计数器减一   
  16.     //glib的很多结构类型和c++的智能指针相似,拥有一个计数器   
  17.     //当计数器为0时,自动释放资源。   
  18.     g_print("g_main_loop_unref\n");   
  19.     g_main_loop_unref(loop);   
  20.     return 0;   
  21. }  

 

好了,现在编译:

  1. gcc -g `pkg-config --cflags --libs glib-2.0 gthread-2.0` mainloop0.c -o mainloop0  

然后运行:

./mainloop0

你会发现程序会在g_main_loop_run函数阻塞,这就是glib main loop了,如果没有人通知它退出,它是不会退出的。
通知循环退出的函数是g_main_loop_quit。
怎么通知呢?主线程被g_main_loop_run阻塞了,没办法运行quit。本来我准备开一个线程,sleep一秒钟,然后调用g_main_loop_quit。不过一想我们都在学习高精尖武器了,还用土枪土炮干啥。使用glib的定时器吧~

  1. //mainloop1.c   
  2. #include    
  3. GMainLoop* loop;   
  4. gint counter = 10;   
  5. gboolean callback(gpointer arg)   
  6. {   
  7.     g_print(".");   
  8.     if(--counter ==0){   
  9.         g_print("\n");   
  10.         //退出循环   
  11.         g_main_loop_quit(loop);   
  12.         //注销定时器   
  13.         return FALSE;   
  14.     }   
  15.     //定时器继续运行   
  16.     return TRUE;   
  17. }   
  18. int main(int argc, char* argv[])   
  19. {   
  20.     if(g_thread_supported() == 0)   
  21.         g_thread_init(NULL);   
  22.     g_print("g_main_loop_new\n");   
  23.     loop = g_main_loop_new(NULL, FALSE);   
  24.     //增加一个定时器,100毫秒运行一次callback   
  25.     g_timeout_add(100,callback,NULL);   
  26.     g_print("g_main_loop_run\n");   
  27.     g_main_loop_run(loop);   
  28.     g_print("g_main_loop_unref\n");   
  29.     g_main_loop_unref(loop);   
  30.     return 0;   
  31. }  

编译运行:

  1. gcc -g `pkg-config --cflags --libs glib-2.0 gthread-2.0` mainloop1.c -o mainloop1   
  2. ./mainloop1  

Yeah!一秒钟后,程序正常退出了!定时器好简单!
今天到此为止。最后思考一个问题,glib的main loop主要提供给gtk使用,是gtk界面事件循环的基础,这是无可非议的。但是,在别的地方,比如我们普通的console、service程序中,有必要用main loop么?main loop还能够应用在哪些场合?

回到前一天的问题,除了交互性界面程序,还有哪些地方适合使用glib的event loop呢?我认为答案应该是,所有需要异步操作的地方都可以用event loop。像文件、管道、设备、socket、timer、idle和其他自定义的事件都可以产生event.
要让GMainLoop能够处理这些类型的event,首先就必须把它们加到GMainLoop去。
首先我们需要了解event loop的这三个基本结构:GMainLoop, GMainContext和GSource。
它们之间的关系是这样的:
GMainLoop -> GMainContext -> {GSource1, GSource2, GSource3......}
每个GmainLoop都包含一个GMainContext成员,而这个GMainContext成员可以装各种各样的GSource,GSource则是具体的各种Event处理逻辑了。在这里,可以把GMainContext理解为GSource的容器。(不过它的用处不只是装GSource)
创建GMainLoop使用函数g_main_loop_new, 它的第一个参数就是需要关联的GMainContext,如果这个值为空,程序会分配一个默认的Context给GMainLoop。
把GSource加到GMainContext呢,则使用函数g_source_attach。

接下来看这个例子,它的作用是从stdin读取字符串,然后反转字符串并输出到屏幕

  1. //mainloop2.c   
  2. #include    
  3. #include    
  4. #include     
  5. GMainLoop* loop;    
  6. //当stdin有数据可读时被GSource调用的回调函数   
  7. gboolean callback(GIOChannel *channel)   
  8. {   
  9.     gchar* str;   
  10.     gsize len;   
  11.     //从stdin读取一行字符串   
  12.     g_io_channel_read_line(channel, &str, &len, NULL, NULL);   
  13.     //去掉回车键()   
  14.     while(len > 0 && (str[len-1] == '\r' || str[len-1] == '\n'))   
  15.         str[--len]='\0';   
  16.     //反转字符串   
  17.     for(;len;len--)   
  18.         g_print("%c",str[len-1]);   
  19.     g_print("\n");   
  20.     //判断结束符   
  21.     if(strcasecmp(str, "q") == 0){   
  22.         g_main_loop_quit(loop);   
  23.     }   
  24.     g_free(str);   
  25. }    
  26. void add_source(GMainContext *context)   
  27. {   
  28.     GIOChannel* channel;   
  29.     GSource* source;   
  30.     //这里我们监视stdin是否可读, stdin的fd默认等于1   
  31.     channel = g_io_channel_unix_new(1);   
  32.     //g_io_create_watch创建一个默认的io监视作用的GSource,下次再研究自定义GSource。参数G_IO_IN表示监视stdin的读取状态。   
  33.     source = g_io_create_watch(channel, G_IO_IN);   
  34.     g_io_channel_unref(channel);   
  35.     //设置stdin可读的时候调用的回调函数   
  36.     g_source_set_callback(source, (GSourceFunc)callback, channel, NULL);   
  37.     //把GSource附加到GMainContext   
  38.     g_source_attach(source, context);   
  39.     g_source_unref(source);   
  40. }    
  41. int main(int argc, char* argv[])   
  42. {   
  43.     GMainContext *context;    
  44.     if(g_thread_supported() == 0)   
  45.         g_thread_init(NULL);   
  46.     //新建一个GMainContext   
  47.     context = g_main_context_new();   
  48.     //然后把GSource附到这个Context上   
  49.     add_source(context);   
  50.     //把Context赋给GMainLoop   
  51.     loop = g_main_loop_new(context, FALSE);    
  52.     g_print("input string('q' to quit)\n");   
  53.     g_main_loop_run(loop);    
  54.     g_main_loop_unref(loop);   
  55.     //Context用完计数器减1   
  56.     g_main_context_unref(context);    
  57.     return 0;   
  58. }  
阅读(3524) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~