3_18_GLib库入门与实践_进程创建

最新推荐文章于 2024-05-09 09:48:19 发布
最新推荐文章于 2024-05-09 09:48:19 发布
阅读量904 收藏 2
点赞数
分类专栏： GLib库入门与实践 文章标签： linux c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/field1003/article/details/123435539
版权

简介

进程可以创建子进程，也可以执行外部程序。在不同平台上，子进程创建及执行外部程序的方法也不相同，GLib提供了一种跨平台的子进程创建接口。在linux上，执行外部程序最常见的是fork+exec方式。GLib提供了同步和异步两种方式创建子进程并执行外部程序。

数据结构

无

函数列表

gboolean	g_spawn_async_with_pipes ()
gboolean	g_spawn_async ()
gboolean	g_spawn_sync ()
gboolean	g_spawn_check_exit_status ()
gboolean	g_spawn_command_line_async ()
gboolean	g_spawn_command_line_sync ()
void	g_spawn_close_pid ()

函数功能分类

// 异步执行一个子进程
gboolean	g_spawn_async_with_pipes ()
gboolean	g_spawn_async ()

// 同步执行一个子进程
gboolean	g_spawn_sync ()

// 检查子进程状态
gboolean	g_spawn_check_exit_status ()

// 对g_spawn_async()和g_spawn_sync()的封装，使用起来更方便
gboolean	g_spawn_command_line_async ()
gboolean	g_spawn_command_line_sync ()

// 关闭子进程（在linux系统上无任何效果）
void	g_spawn_close_pid ()

函数功能说明及综合演示

同步创建子进程

本程序演示同步创建子进程，执行ls命令，并显示运行结果。
演示程序：
源码见glib_examples\glib_spawningproc\glib_spawning_proc_sync

#include <glib.h>

static void test_glib_spawning_proc_sync(void)
{
    GPtrArray *argv = NULL;
    gchar *stdout_str;
    gchar *stderr_str;
    gint estatus;
    GError *error = NULL;

    argv = g_ptr_array_new ();
    g_ptr_array_add (argv, (gpointer)"/bin/ls");
    g_ptr_array_add (argv, (gpointer)"-a");
    g_ptr_array_add (argv, (gpointer)"-l");
    g_ptr_array_add (argv, (gpointer)".");
    g_ptr_array_add (argv, (gpointer)"file_not_exist");
    g_ptr_array_add (argv, NULL);

    g_spawn_sync (NULL, (char**)argv->pdata, NULL, G_SPAWN_DEFAULT, NULL, NULL, &stdout_str, &stderr_str, &estatus, &error);
    g_assert_no_error (error);

    g_print("%s \n", stdout_str);
    g_print("%s \n", stderr_str);

    g_free(stdout_str);
    g_free(stderr_str);
    g_ptr_array_free (argv, TRUE);

    return;
}

gint main(gint argc, gchar **argv) 
{
    test_glib_spawning_proc_sync();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_spawning_proc_sync 
.:
总用量 40
drwxr-xr-x. 3 root root   120 2月  14 00:16 .
drwxr-xr-x. 3 root root    74 2月  14 00:15 ..
-rw-r--r--. 1 root root 12332 2月  14 00:15 CMakeCache.txt
drwxr-xr-x. 5 root root   250 2月  14 00:16 CMakeFiles
-rw-r--r--. 1 root root  1747 2月  14 00:15 cmake_install.cmake
-rwxr-xr-x. 1 root root  8752 2月  14 00:16 glib_spawning_proc_sync
-rw-r--r--. 1 root root  5580 2月  14 00:16 Makefile
/bin/ls: 无法访问file_not_exist: 没有那个文件或目录
多线程同步创建子进程

演示程序：
源码见glib_examples\glib_spawningproc\glib_spawning_proc_multi_thread_sync

#include <glib.h>

struct proc_data
{
    const gchar *proc_path;
    const gchar *proc_param;
};

static gpointer td_spawn_sync_multi_thread_instance (gpointer data)
{
    GError *error = NULL;
    GPtrArray *argv;
    char *stdout_str;
    char *stderr_str;
    int estatus;

    struct proc_data *pdata = (struct proc_data *) (data);
    g_return_val_if_fail((NULL != data), NULL);

    argv = g_ptr_array_new ();
    g_ptr_array_add (argv, (gpointer)pdata->proc_path);
    g_ptr_array_add (argv, (gpointer)pdata->proc_param);
    g_ptr_array_add (argv, NULL);

    g_printf("before spawn sync [%s %s]======================= \n", pdata->proc_path, pdata->proc_param);
    g_spawn_sync (NULL, (char**)argv->pdata, NULL, G_SPAWN_DEFAULT, NULL, NULL, &stdout_str, &stderr_str, &estatus, &error);
    g_assert_no_error (error);
    g_printf("stdout_str=\n%s \n", stdout_str);
    g_printf("stderr_str=\n%s \n", stderr_str);
    g_printf("after spawn sync [%s %s]======================= \n", pdata->proc_path, pdata->proc_param);

    g_free (stdout_str);
    g_free (stderr_str);
    g_ptr_array_free (argv, TRUE);

    gchar c = (char)(pdata->proc_param[strlen(pdata->proc_param)-1]);
    g_printf("c=%c \n", c);

    return GINT_TO_POINTER (c);
}

static void td_multithreaded_test_single_run (GThread **thread, GThreadFunc function, struct proc_data *pdata)
{
    g_return_if_fail(NULL != pdata);
    g_return_if_fail(NULL != thread);
    g_printf("path=%s param=%s\n", pdata->proc_path, pdata->proc_param);

    *thread = g_thread_new(pdata->proc_path, function, (gpointer)pdata);
    g_return_if_fail(NULL != thread);

}

static void td_spawn_sync_multi_thread (void)
{
    GThread *thd1, *thd2, *thd3, *thd4;
    gpointer ret1, ret2, ret3, ret4;

    struct proc_data pdata1 = {"/bin/ls", "-a"};
    td_multithreaded_test_single_run(&thd1, td_spawn_sync_multi_thread_instance, &pdata1);

    struct proc_data pdata2 = {"/usr/bin/sleep", "2"};
    td_multithreaded_test_single_run(&thd2, td_spawn_sync_multi_thread_instance, &pdata2);

    struct proc_data pdata3 = {"/usr/bin/top", "-n 3"};
    td_multithreaded_test_single_run(&thd3, td_spawn_sync_multi_thread_instance, &pdata3);

    struct proc_data pdata4 = {"/bin/echo", "hello world"};
    td_multithreaded_test_single_run(&thd4, td_spawn_sync_multi_thread_instance, &pdata4);

    ret1 = g_thread_join(thd1);
    ret2 = g_thread_join(thd2);
    ret3 = g_thread_join(thd3);
    ret4 = g_thread_join(thd4);

    g_printf("ret1=%c ret2=%c ret3=%c ret4=%c \n", ret1 ,ret2, ret3, ret4);

    return;
}

gint main (gint argc, gchar *argv[])
{
    gint ret;

    g_test_init (&argc, &argv, NULL);

    g_test_add_func ("/gthread/spawn-sync", td_spawn_sync_multi_thread);

    ret = g_test_run();

    return ret;
}

运行结果：

[root@centos7_6 glib_spawning_proc_multi_thread_sync]# ./glib_spawning_proc_multi_thread_sync 
/gthread/spawn-sync: path=/bin/ls param=-a
path=/usr/bin/sleep param=2
path=/usr/bin/top param=-n 3
path=/bin/echo param=hello world
before spawn sync [/usr/bin/sleep 2]======================= 
before spawn sync [/bin/ls -a]======================= 
before spawn sync [/bin/echo hello world]======================= 
before spawn sync [/usr/bin/top -n 3]======================= 
stdout_str=
hello world
 
stderr_str=
 
after spawn sync [/bin/echo hello world]======================= 
c=d 
stdout_str=
.
..
CMakeCache.txt
CMakeFiles
cmake_install.cmake
CMakeLists.txt
glib_spawning_proc_multi_thread_sync
glib_spawning_proc_multi_thread_sync.c
Makefile
 
stderr_str=
 
after spawn sync [/bin/ls -a]======================= 
c=a 
stdout_str=
 
stderr_str=
top: failed tty get
 
after spawn sync [/usr/bin/top -n 3]======================= 
c=3 
stdout_str=
 
stderr_str=
 
after spawn sync [/usr/bin/sleep 2]======================= 
c=2 
ret1=a ret2=2 ret3=3 ret4=d 
OK
异步创建子进程

本程序演示异步创建子进程，执行ls命令，并显示运行结果。
演示程序：
源码见glib_examples\glib_spawningproc\glib_spawning_proc_async

#include <glib.h>

static void test_glib_spawning_proc_async(void)
{
    GPtrArray *argv = NULL;
    GPid child_pid = 0;
    GError *error = NULL;

    argv = g_ptr_array_new ();
    g_ptr_array_add (argv, (gpointer)"/bin/ls");
    g_ptr_array_add (argv, (gpointer)"-a");
    g_ptr_array_add (argv, (gpointer)"-l");
    g_ptr_array_add (argv, (gpointer)".");
    g_ptr_array_add (argv, (gpointer)"not_exist_file");
    g_ptr_array_add (argv, NULL);

    g_spawn_async(NULL, (char**)argv->pdata, NULL, G_SPAWN_DEFAULT, NULL, NULL, &child_pid, &error);

    g_usleep (1*1000*1000);

    g_assert_no_error (error);

    g_spawn_close_pid(child_pid);

    g_ptr_array_free (argv, TRUE);

    return;
}

gint main(gint argc, gchar **argv) 
{
    test_glib_spawning_proc_async();

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_spawning_proc_async 
/bin/ls: 无法访问not-exist-file: 没有那个文件或目录
.:
总用量 40
drwxr-xr-x. 3 root root   121 2月  14 00:07 .
drwxr-xr-x. 3 root root    75 2月  14 00:07 ..
-rw-r--r--. 1 root root 12340 2月  14 00:06 CMakeCache.txt
drwxr-xr-x. 5 root root   251 2月  14 00:07 CMakeFiles
-rw-r--r--. 1 root root  1750 2月  14 00:06 cmake_install.cmake
-rwxr-xr-x. 1 root root  8760 2月  14 00:07 glib_spawning_proc_async
-rw-r--r--. 1 root root  5621 2月  14 00:06 Makefile
同步创建子进程的简单方式

本程序演示使用简单方式同步创建子进程执行ls命令并显示运行结果。
演示程序：
源码见glib_examples\glib_spawningproc\glib_spawning_proc_sync_simple

#include <glib.h>

static void test_glib_spawning_proc_sync_simple(void)
{
    gboolean ret = FALSE;
    gchar *standard_output;
    gchar *standard_error;
    gint estatus;
    GError *error = NULL;

    ret = g_spawn_command_line_sync("/bin/ls -a -l . file_not_exist", &standard_output, &standard_error, &estatus, &error);
    if(FALSE == ret) {
        g_print("g_spawn_command_line_sync error! \n");
        return;
    }

    g_print("%s \n", standard_output);
    g_print("%s \n", standard_error);

    g_free(standard_output);
    g_free(standard_error);

    return;
}

gint main(gint argc, gchar **argv) 
{
    test_glib_spawning_proc_sync_simple();

    return 0;
}

运行结果：

[root@centos7_6 glib_spawning_proc_sync_simple]# ./glib_spawning_proc_sync_simple 
.:
总用量 48
drwxr-xr-x. 3 root root   189 2月  14 00:20 .
drwxr-xr-x. 8 root root   225 2月  14 00:02 ..
-rw-r--r--. 1 root root 12370 2月  14 00:20 CMakeCache.txt
drwxr-xr-x. 5 root root   257 2月  14 00:20 CMakeFiles
-rw-r--r--. 1 root root  1756 2月  14 00:20 cmake_install.cmake
-rw-r--r--. 1 root root   907 2月  14 00:16 CMakeLists.txt
-rwxr-xr-x. 1 root root  8528 2月  14 00:20 glib_spawning_proc_sync_simple
-rw-r--r--. 1 root root   671 2月  14 00:16 glib_spawning_proc_sync_simple.c
-rw-r--r--. 1 root root  5843 2月  14 00:20 Makefile
 
/bin/ls: 无法访问file_not_exist: 没有那个文件或目录
异步创建子进程的简单方式

本程序演示使用简单方式异步创建子进程执行ls命令并显示运行结果。
演示程序：
源码见glib_examples\glib_spawningproc\glib_spawning_proc_async_simple

#include <glib.h>

static void test_glib_spawning_proc_async_simple(void)
{

    gboolean ret = FALSE;
    GError *error = NULL;

    ret = g_spawn_command_line_async("/bin/ls -a -l", &error);

    if(FALSE == ret) {
        g_print("g_spawn_command_line_async return FALSE \n");
        return;
    }

    g_print("test_glib_spawning_proc_async_simple exit \n");

    return;
}

gint main(gint argc, gchar **argv) 
{
    test_glib_spawning_proc_async_simple();

    g_print("main exit \n");

    return 0;
}

运行结果：

[root@centos7_6 build]# ./glib_spawning_proc_async_simple 
test_glib_spawning_proc_async_simple exit 
main exit 
[root@localhost build]# 总用量 40
drwxr-xr-x. 3 root root   128 2月  14 00:12 .
drwxr-xr-x. 3 root root    82 2月  14 00:09 ..
-rw-r--r--. 1 root root 12396 2月  14 00:09 CMakeCache.txt
drwxr-xr-x. 5 root root   258 2月  14 00:12 CMakeFiles
-rw-r--r--. 1 root root  1771 2月  14 00:09 cmake_install.cmake
-rwxr-xr-x. 1 root root  8496 2月  14 00:12 glib_spawning_proc_async_simple
-rw-r--r--. 1 root root  5908 2月  14 00:12 Makefile
field1003
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GMainLoop的实现原理和代码模型
Embedded Linux Development
03-18 1万+
gtk_main()，clutter_main()中主事件循环的实现原理以及代码模型。GUI编程中所谓的事件机制的基本原理。
GLIB：Threads
04-17 630
一组线程称为进程，一个进程内的所有线程通过共享内存来通信。优点是，共享变量/内存通信非常方便；缺点是，多线程程序对程序员编程能力要求很高，否则很容易发生莫名其妙的BUG。多线程就是为并行而设计的，因此程序员不能对线程之间的执行顺序做任何假定；多线程执行的顺序性必须通过在程序代码中的同步原语来直接保证。GLib库设计多线程函数的目标之一是，提高多线程编程的可移植性。
系统调用-进程创建函数glibc部分2
zgolee的专栏
10-07 3207
<br />* 本文的系统调用的分析基于ARM体系结构<br /> * CrossTool：gcc-3.4.5，libc库：glibc-2.3.6<br /> * 本文的内容来自glibc源代码<br /><br /> 上一篇文章中讲述了用户进程如何使用fork、vfork、clone、pthread_create函数，本文将基于glibc-2.3.6源码来跟踪<br /> 这些系统调用是怎么使调用用户进程从用户态切换到内核态的。<br /><br /> 系统调用是操作系统提供的服务，用户程序通过
linux 进程间通信 dbus-glib【实例】详解四（上） C库 dbus-glib 使用（附代码）（编写接口描述文件.xml，dbus-binding-tool工具生成绑定文件）（列集散集函数）
Dontla的博客
01-20 1217
linux 进程间通信 dbus-glib【实例】详解一（附代码）（d-feet工具使用） linux 进程间通信 dbus-glib【实例】详解二（上） 消息和消息总线（附代码） linux 进程间通信 dbus-glib【实例】详解二（下） 消息和消息总线（ListActivatableNames和服务器的自动启动）（附代码） linux 进程间通信 dbus-glib【实例】详解三（下） 数据类型和dteeth（类型签名type域）（层级结构：服务Service --＞ Node（对象、object）
两个调用子进程的方法
飞空静渡
03-26 2282
       原创文章，转载请注明出处，谢谢！               作者：清林，博客名：飞空静渡 前言：我们在写程序时，有时会需要调用到外部的一些程序，因此在linux下，我们会fork（windows下是CreateProcess）一个子进程，然后exec这个子进程，然后在父进程中等待子进程结束并获得子进程的退出码。进一步，如果我们想拦截子进程的输出，并把子进程的输出
六、GLib线程
Creationyang的博客
09-15 878
1线程和进程 1.1 基本概念   进程是系统进行资源分配和调度的一个独立单位。   线程运行在进程中，线程是进程的一个实体，是CPU调度和分配的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不用有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器、栈），但是他可与同属一个进程的其他线程共享进程所拥有的全部资源。 1.2 关系   一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他
3_13_GLib库入门与实践_命令行解析
field1003的博客
03-12 1330
简介 我们常见的如ls，grep, find等命令，通过–help查看，可以看到它们支持非常多的参数，这说明程序支持的功能非常强大，而且这些参数使得程序弹性更大，也更加灵活。如果我们也想写出这样功能强大的程序，GOption将是一个很好用的功能组件。 GOption提供了对程序参数的解析功能，使用GOption可以很方便地创建支持多参数的应用程序。 数据结构 struct GOptionEntry { const gchar *long_name; // 长参数名 gchar sho
U8glib_forwardveg_U8glib\utility_u8glib支持oled_u8glib_u8glib库下载_源
10-03
**U8glib库详解与应用** U8glib是一个为微控制器平台设计的开源图形库，主要用于驱动各种类型的OLED（有机发光二极管）显示屏。这个库由Oliver Klotz开发，旨在简化在嵌入式系统上实现文本、图形以及基本的图像处理...
U8glib-1.19.1.rar_arduino stm32_stm32移植u8glib_u8glib_u8glib stm
09-20
《STM32与Arduino平台上的U8glib库1.19.1移植详解》 在嵌入式系统开发中，图形用户界面（GUI）的实现对于设备的易用性和功能展示至关重要。U8glib是一个广泛使用的轻量级C++类库，专门用于在微控制器上实现低功耗的...
glib-html-2.6.6.tar.gz_glib_glib-2.6.6.tar.b_linux gl
09-22
开发者可以从中学习如何初始化GLib环境、使用数据结构、创建多线程程序，以及如何与其他GObject-based库（如GTK+）集成。同时，通过查看HTML文档，可以深入理解GLib的API，查找函数用法，解决编程问题。
message_pump_glib.rar_On Message
09-24
在Linux操作系统中，GLib库是GObject系统的基础，它提供了一套强大的数据结构、线程管理、事件处理等工具。GLib的消息泵，又称为事件循环，是其核心功能之一，对于理解和编写高效、响应的图形用户界面（GUI）程序至...
适合新手且居家就可以练习的健身动作_arduino_u8glib_
09-30
U8glib arduino driver
向高手学习：glib如何来封装跨平台的线程库
IOT物联网小镇
05-14 1032
文章目录一、前言二、glib 简介三、线程库的设计1. 线程相关的文件2. 数据结构3. 线程的创建4. 线程的执行5. Windows平台函数调用链四、总结 一、前言 这篇文章，按照下面这 2 张图，来描述 glib 在 Linux 和 Windows 平台上，是如何来进行线程库的设计的。 Linux 平台： Windows 平台： 最近写了几篇关于跨平台的应用程序设计思路，有些小伙伴在后台留言询问关于一些通用的跨平台库，看来这方面的需求还是很多的。 所谓的跨平台，无非就是希望用同一份应用程序的代码，
ES6系列之Async/await
十年代码写十年
10-20 174
一、含义 async函数是什么？一句话，它就是Generator函数的语法糖 // 有一个 Generator 函数，依次读取两个文件 const fs = require('fs'); const readFile = function (fileName) { return new Promise(function (resolve, reject) { ...
glib学习记录_________基础篇
三千幻想乡
09-15 664
glib,是linux下的常用的c语言函数库，具有良好的移植性。也可在windows下使用，所以可用来跨平台。     若程序中需要使用glib,则需要包含glib.h头文件。     看一下glib的一些常用类型和宏。 类型： 整数类型gint8,gunit8,gint16,guint16,gint32,guint32,gint64,guint64。 bool类型gboolean 字符类型g
标题：探索未来编程：深入理解并拥抱`async_simple`异步库
最新发布
gitblog_00042的博客
05-09 369
标题：探索未来编程：深入理解并拥抱async_simple异步库 async_simplealibaba/async_simple: 一个简单、轻量级且易于使用的异步 C++ 框架，提供基于协程的组件，如 Lazy（基于 C++20 栈无协程）和 Uthread（基于栈协程）。项目地址:https://gitcode.com/gh_mirrors/as/async_simple 在现代软件开发...
《HelloGitHub》第 75 期
HelloGitHub 的博客
06-28 412
兴趣是最好的老师，HelloGitHub 让你对编程感兴趣！简介HelloGitHub 分享 GitHub 上有趣、入门级的开源项目。https://github.com/521xueweihan/HelloGitHub这里有实战项目、入门教程、黑科技、开源书籍、大厂开源项目等，涵盖多种编程语言 Python、Java、Go、C/C++、Swift...让你在短时间内感受...
17.async 函数
awkticu3808的博客
01-16 158
async 函数async 函数含义ES2017 标准引入了 async 函数，使得异步操作变得更加方便。async 函数是什么？一句话，它就是 Generator 函数的语法糖。前文有一个 Generator 函数，依次读取两个文件。const fs = require('fs'); const readFile = function (fileName) { return...
4_10_GLib库入门与实践_平衡二叉树
field1003的博客
03-13 755
简介 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法）。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的插入，查找，删除时间复杂度均为O(logN)。 数据结构 平衡二叉树的数据结构GTree是不透明结构体，只能作为整体使用，无法直接引用其内部变量。 typedef struct _GTree GTree; 函数列表 GTree * g_tree_new () GTree * g_tree
glib如何使用g_main_loop_new来创建主进程
06-09
`g_main_loop_new()` 函数可以用来创建一个新的主循环，主循环可以用于事件处理和异步任务的调度。下面是一个简单的示例程序，展示如何使用 `g_main_loop_new()` 函数创建一个主进程： ```c #include <glib.h> static gboolean on_timeout(gpointer data) { g_print("Hello, world!\n"); return G_SOURCE_CONTINUE; } int main(int argc, char** argv) { GMainLoop* loop = g_main_loop_new(NULL, FALSE); guint timeout_id = g_timeout_add_seconds(1, on_timeout, NULL); g_print("Starting main loop...\n"); g_main_loop_run(loop); g_source_remove(timeout_id); g_main_loop_unref(loop); return 0; } ``` 以上代码创建了一个主循环，并注册了一个每秒调用一次的定时器事件。`g_main_loop_run()` 函数会启动主循环，并一直运行，直到调用 `g_main_loop_quit()` 函数停止循环。在这个例子中，调用 `g_main_loop_quit()` 函数需要在 `SIGINT` 信号处理函数中执行： ```c static void on_sigint(int signum) { g_print("Received SIGINT, stopping main loop...\n"); g_main_loop_quit(loop); } int main(int argc, char** argv) { // ... signal(SIGINT, on_sigint); // ... } ``` 这样，当用户在终端中按下 `Ctrl+C` 键时，就会触发 `SIGINT` 信号，程序会执行 `on_sigint()` 函数，从而停止主循环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值