linux多进程编程

最新推荐文章于 2023-04-10 10:39:50 发布
最新推荐文章于 2023-04-10 10:39:50 发布
阅读量300 收藏
点赞数
分类专栏： Linux 文章标签： linux 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41324483/article/details/103755318
版权

文章目录

创建进程

替换进程映像

exec系列函数可以创建（启动）新进程，并替换原进程的进程映像。exec系列函数如下所示：

#include <unistd.h>
int execl(const char *path, const char *arg, ...,(char  *) NULL);
int execlp(const char *file, const char *arg, ...,(char  *) NULL);
int execle(const char *path, const char *arg, ..., (char *) NULL, char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);

这些函数按参数个数是否可变，可以分为两类。
①execl()、execlp()、execle()，他们的特点是：
1）参数个数可变；
2）最后一个arg参数为(char *) NULL。
3）函数名中带字母“l”。

②execv()、execp()、execvp()，他们的特点是：
1）参数个数不可变；
2）第二个参数是一个字符串数组，数组的最后一个元素需是(char *) NULL。
3）函数名中带字母“v”。

按第一个参数的类型，可以分为两类。
①execlp()、execvp()、execvpe()，他们的特点是：
1）第一个参数名为“file”；
2）第一个参数为被调用（启动）的可执行文件名，函数会通过PATH环境变量搜索该可执行文件，如果该文件不在PATH定义的路径中，则需要使用全路径名。
3）函数名中带字母“p”，表是可以通过PATH环境变量搜索。

②execl()、execle()、execv()，他们的特点是：
1）第一个参数名为“path”；
2）第一个参数为被调用（启动）的可执行文件的路径名，无论PATH环境变量是否包含该可执行文件的路径。
3）函数名中不带字母“p”，表是不可以通过PATH环境变量搜索

示例1：

#include <stdio.h>
#include <unistd.h>
void exec1()
{	
	printf("enter exec1\n");
	const char *path = "/bin/ps";//此处需要使用路径名
	const char *arg = "ps";
	const char *arg1 = "";
	execl(path,arg, (char	*) NULL);
	printf("leave exec1\n");
}
void main()
{
	printf("enter main\n");
	exec1();
	printf("leave main\n");
}

打印结果：

enter main
enter exec1
   PID TTY          TIME CMD
 10305 pts/18   00:00:00 bash
 11156 pts/18   00:00:00 ps

分析：函数execl执行成功之后原进程映像被“ps”程序替换，故原进程中的

printf("leave exec1\n");
printf("leave main\n");

这两句为执行。

示例2：

#include <stdio.h>
#include <unistd.h>
void exec2()
{	
	printf("enter exec2\n");
	const char *file = "ps";//此处使用可执行文件名
	const char *arg = "ps";
	const char *arg1 = "";
	execlp(file,arg, (char	*) NULL);
	printf("leave exec2\n");
}
void main()
{
	printf("enter main\n");
	exec2();
	printf("leave main\n");
}

打印结果：

enter main
enter exec2
   PID TTY          TIME CMD
 10305 pts/18   00:00:00 bash
 11202 pts/18   00:00:00 ps

分析：函数execlp执行成功之后原进程映像被“ps”程序替换，故原进程中的

printf("leave exec2\n");
printf("leave main\n");

这两句为执行。

示例3：

#include <stdio.h>
#include <unistd.h>
void exec3()
{	
	printf("enter exec3\n");
	const char *path = "/bin/ps";
	const char *arg = "ps";
	const char *arg1 = "";
	char * const envp[] = {"/bin:/usr/bin",NULL};//此处环境变量参数可有可无。
	execle(path,arg, (char	*) NULL,NULL);
	printf("leave exec3\n");
}
void main()
{
	printf("enter main\n");
	exec3();
	printf("leave main\n");
}

打印结果：

enter main
enter exec3
   PID TTY          TIME CMD
 10305 pts/18   00:00:00 bash
 11216 pts/18   00:00:00 ps

分析：函数execle执行成功之后原进程映像被“ps”程序替换，故原进程中的

printf("leave exec3\n");
printf("leave main\n");

这两句为执行。

示例4：

#include <stdio.h>
#include <unistd.h>
void exec4()
{	
	printf("enter exec4\n");
	const char *path = "ps";//"/bin/ps"
	char *const argv[] = {"ps",NULL};
	execv(path,argv);
	printf("leave exec4\n");
}
void main()
{
	printf("enter main\n");
	exec4();
	printf("leave main\n");
}

打印结果：

enter main
enter exec4
leave exec4
leave main

分析：由于函数execv第一个参数未使用路径名，故execv执行失败，创开启新进程。

示例5：

#include <stdio.h>
#include <unistd.h>
void exec5()
{	
	printf("enter exec5\n");
	const char *file = "ps";
	char *const argv[] = {"ps",NULL};
	execvp(file,argv);
	printf("leave exec5\n");
}
void main()
{
	printf("enter main\n");
	exec5();
	printf("leave main\n");
}

打印结果：

enter main
enter exec5
   PID TTY          TIME CMD
 10305 pts/18   00:00:00 bash
 11246 pts/18   00:00:00 ps

分析：函数execvp执行成功之后原进程映像被“ps”程序替换，故原进程中的

printf("leave exec5\n");
printf("leave main\n");

这两句为执行。

示例6：

#include <stdio.h>
#include <unistd.h>
void exec6()
{	
	printf("enter exec6\n");
	const char *file = "ps";
	char *const argv[] = {"ps",NULL};
	char * const envp[] = {"/bin:/usr/bin",NULL};
	execvpe(file,argv,envp);
	printf("leave exec6\n");
}
void main()
{
	printf("enter main\n");
	exec6();
	printf("leave main\n");
}

打印结果：

enter main
enter exec6
   PID TTY          TIME CMD
 10305 pts/18   00:00:00 bash
 11258 pts/18   00:00:00 ps

分析：函数execvpe执行成功之后原进程映像被“ps”程序替换，故原进程中的

printf("leave exec6\n");
printf("leave main\n");

这两句为执行。

复制进程映像

如果想要进程同时执行多个函数，可以调用fork函数创建一个与原进程完全分离的进程。这个系统调用复制当前进程，并在进程表中创建一个新的表项，该表项与原进程表项基本相同。新进程与原进程几乎一模一样，执行的代码也完全相同，但新进程有自己独立的数据空间、环境和文件描述符。fork函数的部分manual如下所示：

NAME
       fork - create a child process
SYNOPSIS
       #include <unistd.h>
       pid_t fork(void);
RETURN VALUE
       On success, the PID of the child process is returned in the parent, and
       0 is returned in the child.  On failure, -1 is returned in the  parent,
       no child process is created, and errno is set appropriately.

fork用法介绍

  • fork函数执行成功后会复制一份当前进程（父进程）的进程映像，即子进程。此时子进程的PID会返回给父进程，“0”会返回给子进程。
  • fork函数执行失败则返回“-1”给父进程。
    用法示例
#include <stdio.h>
#include <unistd.h>

int main()
{
	pid_t pid;
	pid = fork();
	if(pid == -1){
		printf("fork failed\n");
		return 1;
	}else if(pid){
		printf("The father return value is %d\n",pid);
		printf("The father pid is %d\n",getpid());		//获取进程id
		printf("The father ppid is %d\n",getppid());	//获取父进程id
		while(1);
	}else{
		printf("The child return value is %d\n",pid);
		printf("The child pid is %d\n",getpid());	//获取进程id
		printf("The child ppid is %d\n",getppid());	//获取父进程id
		while(1);
	}
	return 0;
}

The father return value is 12002
The father pid is 12001
The father ppid is 10305
The child return value is 0
The child pid is 12002
The child ppid is 12001

等待进程

系统调用wait可以挂起父进程，等待子进程结束。

NAME
       wait, waitpid, waitid - wait for process to change state
SYNOPSIS
       #include <sys/types.h>
       #include <sys/wait.h>
       pid_t wait(int *status);
       pid_t waitpid(pid_t pid, int *status, int options);
       int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
                       /* This is the glibc and POSIX interface; see
                          NOTES for information on the raw system call. */

使用示例

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	pid_t pid;
	int status = 0;
	pid = fork();
	if(pid == -1){
		printf("fork failed\n");
		return 1;
	}else if(pid){
		printf("The father return value is %d\n",pid);
		wait(&status);
		printf("The father pid is %d\n",status);
		printf("The father pid is %d\n",getpid());
		printf("The father ppid is %d\n",getppid());
		//while(1);
	}else{
		printf("The child return value is %d\n",pid);
		printf("The child pid is %d\n",getpid());
		printf("The child ppid is %d\n",getppid());
		//while(1);
	}
	return 0;
}

The father return value is 12118
The child return value is 0
The child pid is 12118
The child ppid is 12117
The father pid is 0
The father pid is 12117
The father ppid is 10305

进程间通信

管道

  • 创建管道
#include <unistd.h>
int pipe(int pipefd[2]);

数组pipefd用于返回指向管道末端的两个文件描述符。pipefd[0]为管道的读出端，pipefd[1]为管道的写入端。
进程写入到管道写入端的数据由内核缓冲，直到另一进程从管道的读出端读取。

  • 应用示例
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char *argv[])
{
    int pipefd[2];
    pid_t cpid;
    char buf;
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <string>\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }
    cpid = fork();
    if (cpid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    if (cpid == 0) {    /* Child reads from pipe */
        close(pipefd[1]);          /* Close unused write end */
        while (read(pipefd[0], &buf, 1) > 0)
            write(STDOUT_FILENO, &buf, 1);
        write(STDOUT_FILENO, "\n", 1);
        close(pipefd[0]);
        _exit(EXIT_SUCCESS);
    } else {            /* Parent writes argv[1] to pipe */
        close(pipefd[0]);          /* Close unused read end */
        write(pipefd[1], argv[1], strlen(argv[1]));
        close(pipefd[1]);          /* Reader will see EOF */
        wait(NULL);                /* Wait for child */
        exit(EXIT_SUCCESS);
    }
}

信号量

消息队列

共享内存

高阳.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux api获取进程,进程管理 – Linux内核API get_task_mm
weixin_42513814的博客
04-30 774
get_task_mm函数功能描述：此函数根据提供的任务描述符信息，获取其对应的内存信息，此内存信息保存在mm_struct结构体类型的变量中。get_task_mm文件包含#include get_task_mm函数定义在内核源码中的位置：linux-3.19.3/kernel/fork.c函数定义格式：struct mm_struct *get_task_mm(struct task_stru...
linux进程编程
Vsheng969的博客
06-13 210
一、什么是进程？ 一般来讲，进程定义为正在运行的程序的实例，简单地说，进程就是一个正在运行的程序。 程序 (program)：通常为二进制，放置在储存媒体中 (如硬盘、光盘、软盘、磁带等)， 为实体文件的型态存在； 进程 (process)：程序被触发后，运行者的权限与属性、程序的程序码与所需数据等都会被加载内存中， 操作系统并给予这个内存内的单元一个识别码 (PID)，可以说，进程就是一个正在运行中的程序。 进程不仅仅包含了正在运行的代码，还包括了运行代码所需要的各种资源。内核中使用进程控制块PCB（pr
Linux之多进程详解
夹心狗勾的博客
03-08 1154
Linux之多进程详解及实现服务端多进程
Linux C：进程及其相关API
weixin_55023180的博客
10-25 812
首先要区别进程（process）的程序（program）。所谓进程就是进行时态的程序，在内存中没有运行的应用就是程序，在闪存中跑起来的应用就是进程。
Linux进程编程2——与“进程”相关的API
主要记录嵌入式学习与开发过程。
07-13 2283
以下内容源于网络资源的学习与整理，如有侵权请告知删除。
Linux系统编程之进程及相关API
m0_49507996的博客
07-19 197
进程什么是进程 什么是进程 简单来说进程是程序的动态的概念，进程是当程序运行起来时就会存在进程 图中的a.out就是一个程序，而当其运行起来后，可以通过 ps -aux |grep a.out 来查看进程 可以看到进程的pid号，以及运行的状态等信息 ...
Linux进程编程
qq_49856905的博客
09-02 202
Linux进程编程 使用fork函数创建一个进程
Linux多进程编程测试例子
04-06
这个“Linux多进程编程测试例子”很可能是为了帮助开发者理解和实践如何在Linux环境下创建、管理以及通信多进程。下面将详细讨论多进程编程的基本概念、API使用、进程间通信（IPC）以及相关的测试策略。 1. **进程...
Linux多进程编程-详细讲解.pptx
11-15
Linux 多进程编程详细讲解 Linux 多进程编程是指在 Linux 操作系统中，使用多个进程来完成不同的任务，以提高系统的性能和可靠性。多进程编程是 Linux 编程中的一种重要技术，广泛应用于服务器端编程、嵌入式系统...
Linux多进程编程
04-09
Linux多进程编程这份文档详细讲述了Linux下的多进程编程现实例程。
win32API进程相关函数
08-07
win32、API进程相关函数 参考 MSDN
嵌入式linux多进程编程
06-23
在"嵌入式Linux多进程编程"这个主题中，我们将深入探讨如何在嵌入式设备上实现多进程以及相关的技术要点。 首先，理解进程的基本概念至关重要。进程是程序的一次执行实例，每个进程都有自己的虚拟地址空间，包括...
linux启动程序api编程,Android应用程序启动过程源代码分析
weixin_33655208的博客
05-03 91
前文简要介绍了Android应用程序的Activity的启动过程。在Android系统中，应用程序是由Activity组成的，因此，应用程序的启动过程实际上就是应用程序中的默认Activity的启动过程，本文将详细分析应用程序框架层的源代码，了解Android应用程序的启动过程。在上一篇文章Android应用程序的Activity启动过程简要介绍和学习计划中，我们举例子说明了启动Android应用...
Linux进程之API（下）（system、popen）
weixin_45637109的博客
04-10 187
成功调用ps程序，而且相对于exec函数，system还会继续执行下面的代码。比system在应用中的。：以获取运行的输出结果。
Linux 进程启动方法
小刚专栏
02-20 1348
1. 调用系统命令，完成一些操作，或判定结果 或获取结果 2. 作为启动进程，调用第三方进程，并监控进程是否退出 3. 加载升级进程，升级进程kill调用者或调用者自行退出，完成升级
Linux中常用的的API
weixin_42065178的博客
06-27 4774
标准C库的IO函数通常是可以跨平台的。标准C库会调用Linux操作系统提供的API。文件描述符在进程的内核区的PCB（进程控制块）中的文件描述表中，通过系统调用返回给程序。文件描述符表是一个整型数组，默认大小是1024（也就是最多同时能打开1024个文件），前三个整型元素由系统占用，0表示STDIN，1表示STDOUT，2表示STDERR，每打开一个新文件就会占用一个文件描述符，而且是空闲的最小的一个文件描述符。调用Linux中的open方法就能够返回一个文件描述符。....................
Linux多进程
Bill Jenkins博客
05-28 1578
本文目录@[TOC](本文目录)前言第1章1.1 xxx概述1.1.1 xxxx系统框图1.1.2 xxx系统流程1.2 具体描述第2章2.1 xxx原理2.1.1 xxxx设计2.1.1 xxx功能2.2 xx实现小结附录-参考文献 前言 … 第1章 1.1 xxx概述 1.1.1 xxxx系统框图 1.1.2 xxx系统流程 1.2 具体描述 第2章 2.1 xxx原理 2.1.1 xxxx设计 2.1.1 xxx功能 2.2 xx实现 … 小结 附录-参考文献 ...
Ubuntu查看和设置环境变量
人来人往的博客
02-03 2972
1 查看环境变量 查看环境变量有三个命令： env：env命令是environment的缩写，用于列出所有的环境变量； export：单独使用export命令也可以像env列出所有的环境变量，不过export命令还有其他额外的功能； echo $PATH： echo $PATH用于列出变量PATH的值，里面包含了已添加的目录。 2 设置方式 设置环境变量通常有两种方式。 2.1 把你的路径加入PATH 可以直接添加到环境变量PATH中。$PATH表示变量PATH的值，包含已有的目录。 这种方法需要注意路径的
linux 多进程编程
最新发布
07-01
Linux多进程编程是指在Linux操作系统下，使用多个进程同时执行任务的编程方式。 在Linux中，每个进程都是一个独立的执行环境，有自己独立的地址空间和资源。多进程编程可以通过创建多个进程来同时执行不同的任务，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值