Linux的进程间的通信

最新推荐文章于 2023-04-14 22:22:44 发布
最新推荐文章于 2023-04-14 22:22:44 发布
阅读量383 收藏
点赞数
分类专栏： Linux/Unix 文章标签： linux
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/78300726
版权 

#define  STDIN_FILENO     		0
#define  STDOUT_FILENO    		1
#define  STDERR_FILENO    		2

一，管道进程的pipe函数和dup2函数组合使用父子进程间通信

参数是数组管道文件描述符

pipe参数是:

  1. fd[0]是读文件描述符,
  2. fd[2]是写文件描述符
 int pipe(int pipefd[2]);

案例1:

/*************************************************************************
	> File Name: pipe.c
	> Author: songli
	> QQ: 2734030745
	> Mail: 15850774503@163.com
    > CSDN: http://my.csdn.net/Poisx
	> github: https://github.com/chensongpoixs
	> Created Time: Fri 20 Oct 2017 10:22:29 PM CST
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>



int main(int argc, char *argv[])
{
    //管道数组文件描述符
    int fd[2];       
    int ret;
    

    int i, n = 2;
    //创建管道
    ret = pipe(fd);

    //文件描述符
    pid_t pid;

    if (ret < 0)
    {
        perror("pipe error");
        return -1;
    }

    for (i = 0; i < n; i++)
    {
        //创建子进程
        pid = fork();
        if (pid < 0) // 异常处理
        {
            perror("fork error");
            return -1;
        }
        else if (pid > 0) // 父进程的操作
        {
            printf("father fpid:%d, cpid:%d\n", getpid(), pid);
        }
        else if (pid == 0) //子进程的操作
        {
            printf("child fpid:%d, cpid:%d\n", getppid(), getpid());
            break; //防止子线程创建子进程
        }
    }
    //===============  子进程的操作=============================
    if (i == 0)
    {
        printf("no child n = %d, cpid:%d\n", i, getpid());
        //=================写入数据 =====================
        close(fd[0]); //关闭读取文件描述符
        //标准输入也是 文件描述符   中的1
        dup2(fd[1], STDOUT_FILENO);
        // 执行  写入命令
        execlp("ps", "ps", "-ef", NULL);
        close(fd[1]); //关闭写入文件描述符
        return 0; //signal  正常退出
    }
    if (i == 1)
    {
        printf("no child n = %d, cpid:%d\n", i, getpid());
        //=================写入数据 =====================
        close(fd[1]); //关闭 写描述符文件描述符
        //标准输出也是 文件描述符   中的1
        dup2(fd[0], STDIN_FILENO);
        // 执行  写入命令
        execlp("grep", "grep", "--color", "bash", NULL);
        close(fd[0]); //关闭写入文件描述符
        return 0; //signal  正常退出
    }

    //=================      主进程的操作 ========================
    if (i == n)
    {
        //pcb 进程块pid
        pid_t wpid;
        int status;

        while (1)
        {
            //等待线程
            wpid = waitpid(-1, &status, WNOHANG );
            if (wpid == 0) //有子进程程的操作
            {
                sleep(1);
                continue;
            }
            else if (wpid == -1) // 没有子进程的操作
            {
                printf("退出子进程的wpid：%d\n", wpid);
                exit(0);
            }
            else if (wpid > 0)  //什么原因退出
            {
                if (WIFEXITED(status)) //正常退出
                {
                    printf("子进程wpid:%d, status:%d\n", wpid, WEXITSTATUS(status));
                }
                if (WIFSIGNALED(status))
                {
                    printf("子进程wpid:%d, status:%d\n", wpid, WTERMSIG(status));
                    
                }
            }
        }

    }
	return 0;
}

效果图

1, 和fcntl函数一起使用可以数组read函数非阻塞
/*************************************************************************
	> File Name: pipe_fcntl.c
	> Author: songli
	> QQ: 2734030745
	> Mail: 15850774503@163.com
    > CSDN: http://my.csdn.net/Poisx
	> github: https://github.com/chensongpoixs
	> Created Time: Fri 20 Oct 2017 10:47:08 PM CST
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>



int main(int argc, char *argv[])
{
    //数组文件描述符
    int fd[2];
    int ret;
    char buf[1024];

    //创建管道
    ret = pipe(fd);
    if (ret < 0)
    {
        perror("pipe error");
        return -1;

    }

    //pcb进程控制块pid
    pid_t pid;

    //创建子线程
    pid = fork();
    if (pid < 0) //异常处理
    {
        perror("fork error");
        return -1;
    }
    else if (pid > 0) //父进程的处理
    {
        printf("father fpid:%d, cpid:%d\n", getpid(), pid);

        //==============读取数据==================
        close(fd[1]); //关闭写文件操作
        //==================    在同一个进程中使用非阻塞使用fcntl函数 =========================================
        int flags = fcntl(fd[0], F_GETFL );
        flags |= O_NONBLOCK;
        fcntl(fd[0], F_SETFL, flags);
        //=============================================================
        while(1)
        {
            sleep(1);
            memset(buf, 0x00, sizeof(buf));
            ret = read(fd[0], buf, sizeof(buf));
            printf("读取数据的大小：%d buf = %s\n", ret, buf);
        }
        close(fd[0]);

    }
    else if (pid == 0) //子进程的操作
    {
       printf("child fpid:%d, cpid:%d\n", getppid(), getpid());
       //========== 写操作=================== 
        close(fd[0]); //关闭读取文件描述符
        int i = 0;
        while (1)
        {
            sleep(1);
            memset(buf, 0x00, sizeof(buf));
            sprintf(buf, "[%d]:[%s]", i++, "陈丽， 杨艳");
            write(fd[1], buf, strlen(buf));
        }
        close(fd[1]);
    }




	return 0;
}

** 效果图**

二，管道 mkfifio函数的使用

mkfifo命令生成管道文件

mkfifo函数 第一参数路径， 第二是权限

 int mkfifo(const char *pathname, mode_t mode);
写入数据
/*************************************************************************
	> File Name: fifo_write.c
	> Author: songli
	> QQ: 2734030745
	> Mail: 15850774503@163.com
    > CSDN: http://my.csdn.net/Poisx
	> github: https://github.com/chensongpoixs
	> Created Time: Fri 20 Oct 2017 11:22:50 PM CST
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>



int main(int argc, char *argv[])
{
    // 文件描述符
    int fd;
    
    int ret;
    //判断是否创建管道文件
    if ((ret = access("./myfifo", F_OK)) == -1)
    {
        //创建管道
        ret =  mkfifo("./myfifo", 0777);
        if (ret < 0)
        {
            perror("mkfifo error");
            return -1;
        }
    }

    //打开文件
    fd = open("./myfifo", O_RDWR);
    if (fd < 0)
    {
        perror("open error");
        return -1;
    }

    //=====================写数据到管道中============================

    while (1)
    {
        sleep(1);
        write(fd, "陈丽, 杨艳", strlen("杨艳"));
    }

    close(fd);


	return 0;
}
1, 读取数据
/*************************************************************************
> File Name: fifo_read.c
> Author: songli
> QQ: 2734030745
> Mail: 15850774503@163.com
> CSDN: http://my.csdn.net/Poisx
> github: https://github.com/chensongpoixs
> Created Time: Fri 20 Oct 2017 11:31:07 PM CST
************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h>




int main(int argc, char *argv[])
{
    //文件描述符
    int fd;


    int ret;

    char buf[1024];
    //检测是否有管道文件
    if ((ret = access("./myfifo", F_OK)) == -1)
    {
        ret = mkfifo("./myfifo", 0777);
        if (ret < 0)
        {
            perror("mkfifo error");
            return -1;
        }
    }

    //打开管道文件
    fd = open("./myfifo", O_RDWR);
    if (fd < 0)
    {
        perror("open error");
        return -1;
    }

    //==============读取管道中数据=========================

    while (1)
    {
        //=================   设置read函数非阻塞  ==================
/*        int flags = fcntl(fd, F_GETFL);
        flags |= O_NONBLOCK;
        fcntl(fd, F_SETFL, flags);*/
        sleep(1);
        memset(buf, 0x00, sizeof(buf));
        ret = read(fd, buf, sizeof(buf));
        printf("读取数据：%d, buf = %s\n", ret, buf);
    }
    //关闭文件
    close(fd);

    return 0;
}

效果图

三，mmap内存映射的机制

每个应用程序有虚的4个G的内存 由MMU把实际 要用的映射到内存中就是内核

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/mman.h>



int main(int argc, char *argv[])
{
	//文件描述符
	int fd;
	int len;
	fd = open("./text.log", O_RDWR);
	if (fd < 0)
	{
		perror("open error");
		return -1;
	}
	//文件大小
	len = lseek(fd, 0, SEEK_END);

	//参数一：NULL
	//参数二：文件的大小，不能为0
	//参数三：权限
	//参数四：是否同步的硬盘中
	//参数五：文件指针
	//参数六：文件开始位置
	void *ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	if (ptr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}
	char *p = (char*)ptr;
	strcpy(p, "陈丽");

	//参数一：文件指针
	//参数二：文件大小
	munmap(ptr, len);
	//关闭文件
	close(fd);


	return 0;
}
1, 没有告关系的进程之间通信

写数据的

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char *argv[])
{
	//文件描述符
	int fd;
	int len; //文件大小
	int ret; //状态码
	//打开文件
	fd = open("./text.log", O_RDWR);
	if (fd < 0)
	{
		perror("open error");
		return -1;
	}
	//文件大小
	len = lseek(fd, 0, SEEK_END);
	//映射到内核中
	void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	if (ptr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}
	char * p = (char *) ptr;
	strcpy(p, "陈丽， 王蓉");


	//关闭
	munmap(ptr, len);
	close(fd);


	return 0;
}

读取数据

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>

/**
读取数据mmap_read

**/

int main(int argc, char *argv[])
{
	//文件指针
	int fd;
	int len; //文件大小
	void * ptr; //映射内存地址
	char buf[1024];
	//打开文件
	fd = open("./text.log", O_RDWR);
	if (fd < 0)
	{
		perror("open error");
		return -1;
	}

	//文件大小
	len = lseek(fd, 0, SEEK_END);
	//创建映射
	ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
	if (ptr == MAP_FAILED)
	{
		perror("mmap error");
		return -1;
	}

	//=============读取 map内存的数据===================
	//while (1)
	//{
		//memset(buf, 0x00, sizeof(buf));
	//	read(fd, buf, sizeof(buf));
	char *p = (char *) ptr;
		printf("读取数据：%s\n", p);
	//}
	munmap(ptr, len);

	//关闭文件操作
	close(fd);
	
	return 0;
}

四, 进程间通信的自定义

/*
 *父子进程交替数数。
 */
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <error.h>

pid_t pid;

void sig_handler_p(int sig) //parent 父进程
{
	static int i = 1;
	printf("pid = %d, I'm father\t%d\n", getpid(), i);
	sleep(1);
	i += 2;
	kill(pid, SIGUSR1);     //为避免竞态条件出现,应该在捕捉函数内完成数数及信号发送.
}

void sig_handler_c(int sig) //child  子进程
{
	static int i = 2;
	printf("pid = %d, I am child\t%d\n", getpid(), i);
	sleep(1);
	i += 2;
	kill(getppid(), SIGUSR2);
}

int main(void)
{
	struct sigaction newact_p, oldact_p;        //父进程使用
	struct sigaction newact_c, oldact_c;        //子进程使用

	//子进程响应SIGUSR1
	newact_c.sa_handler = sig_handler_c;
	sigemptyset(&newact_c.sa_mask);
	newact_c.sa_flags = 0;
	sigaction(SIGUSR1, &newact_c, &oldact_c);//注册捕捉信号(捕捉的信号,传入参数新的处理方法,传出参数旧的处理方法)

	//父进程响应SIGUSR2
	newact_p.sa_handler = sig_handler_p;
	sigemptyset(&newact_p.sa_mask);
	newact_p.sa_flags = 0;
	newact_p.sa_flags |= SA_RESTART;//多加这一行可以将被信号打断的系统调用重启。
	sigaction(SIGUSR2, &newact_p, &oldact_p);//注册捕捉信号(捕捉的信号,传入参数新的处理方法,传出参数旧的处理方法)

	pid = fork();//此时父子进程都注册了2个信号处理函数，但都只会收到其中一个信号，子进程只收SIGUSR1，父进程只收SIGUSR2
	if (pid == 0) 
	{					//子进程
		while (1);
	}
	else 
	{						//父进程
		raise(SIGUSR2);//自己给自己发信号2
		if (wait(NULL)) 
		{			//wait有可能被信号打断。
			perror("wait error");
		}
		//while (1);				//或者不使用wait使用这条语句也可以实现。
	}
	
	return 0;
}
chen_song_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 管道 （双向管道流模型）
fuli1215的专栏
05-08 1847
#include #include void WriteG(int fd,char *str,int len)// 写入固定长度报文 { char buf[255]; memset(buf,0,sizeof(buf)); sprintf(buf,"%s",str); write(fd,buf,len); } char *ReadG(int fd,int len) { //读取固定长度的报文 char buf[255]; memset(buf,0,sizeof(buf)); rea
Linux进程间通信
05-20
在Linux操作系统中，进程间通信（IPC，Inter-Process ...总结来说，Linux进程间通信是实现多进程协同工作、提高系统效率的关键。理解并灵活运用各种IPC方式，有助于我们设计出高效、可靠的多线程和多进程应用程序。
进程间通讯
WKH
07-25 191
进程间通讯是进程间数据传输 数据共享 进程控制 时间通知 , 根据需求的不同,操作系统提供多种不同的进程间通信方式 进程通讯–提供一个公共的媒介 管道 linux管道继承于unix:匿名管道/命名管道 管道是一个半双工通信: 提供双向选择,但是只能单向传输 管道创建成功后,提供一个io操作:返回文件描述符作为句柄 句柄(文件描述符)有两个: 一个用于读取数据,一个用于写入数据 匿名管道只能用于有血...
Linux进程间通信——管道通信
热门推荐
studyhardi的博客
05-05 1万+
1. 进程间通信概述 进程间通信（Inter-Process Communication, IPC）是指在两个或者多个不同得劲进程间传递或者交换信息，通过信息的传递建立几个进程间的联系，协调一个系统中的多个进程之间的行为。 1.1 进程间通信的工作原理 进程与进程之间是相互独立的，各自运行在自己的虚拟内存中。要想在进程与进程间建立联系，需要通过内核，在内核中开辟一块缓冲区，两个进程的信息在缓冲区中...
Linux 上实现双向进程间通信管道
netguang的专栏
05-14 1488
技术要点： 1. 使用命名管道，实现进程间管道的访问 2. 管道操作使用长连接 3. 使用信号量共享key实现进程锁 Linux管道是单向的，要实现进程间双向通讯，需要使用两个管道：一个负责Client发送数据到server，另一个负责server返回数据到Client；对于一个client访问server的情况（相当于一个进程访问server）,Client发送与接收数据不会...
进程间通信--双向管道实现
Victor_psl的博客
08-25 1515
地址链接：https://www.ibm.com/developerworks/cn/linux/l-pipebid/index.html Linux 上实现双向进程间通信管道 问题和常见方法 Linux 提供了 popen 和 pclose 函数 (1)，用于创建和关闭管道与另外一个进程进行通信。其接口如下： 1 2 FILE *popen(const char *command， const char *mode); int pclose
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
linux-linux进程间通信方式汇总.zip
最新发布
02-26
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
使用线程完成创建两个fork子进程，使父进程和子进程交替执行
W_xwp的博客
04-23 2174
作业内容： 多线程程序并发设计 编写程序，利用 fork()产生两个子进程，首先显示一下两个子进程及父进程的进程标 识符；然后让父进程显示 1-26 个数字，子进程 1 显示 26 个大写字母，子进程 2 显示 26 个 小写字母。让大小写字母及数字是夹杂交错输出的。修改程序，让两个子进程夹杂输出结束 后，父进程输出开始 背景知识 提示：这里描述项目中遇到的问题： 例如：数据传输过程中数据不时出现丢失的情况，偶尔会丢失一部分数据 APP 中接收数据代码： @Override p
linux的SIGUSR1和SIGUSR2信号例子
e891377的专栏
08-21 5040
linux的SIGUSR1和SIGUSR2信号例子 利用SIGUSR1和SIGUSR2在父子进程之间进行消息传递，实现父子进程交替报数(间隔1秒) kill(pid,sig) 发送信号 父子进程捕捉信号 代码 #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <fcntl.h> #include <signal.h> #include <sys/type
父子进程交替数数(时序竞态记录)
weixin_45397797的博客
04-24 212
#include <stdio.h> #include <unistd.h> #include <sys/stat.h> #include <sys/types.h> #include <signal.h> int num = 0; void actionfunc(int signo) { printf("%d\n", num); num += 2; } int main() { pid_t pid; sigset_t newmask, oldma
Linux总结（三） ----进程间通讯与线程
努力进阶的小菜鸟
07-23 285
目录 一、库函数 系统调用和库函数的区别？ 二、进程间通讯 1.管道 2.信号量 红绿灯 3.共享内存 同步和异步的方式？ 阻塞与非阻塞 4.消息队列 线程于进程的区别？ 三、线程同步的方法： 信号量和互斥锁的区别？ 线程的实现？ Linux线程的实现 线程安全 一、库函数 系统调用和库函数的区别？ 库函数的实现在库里，运行在用户态 系统调用的实现在内核...
管道 mkfifio函数的使用
alpha_love的博客
02-17 384
mkfifo命令生成管道文件 mkfifo函数 第一参数路径， 第二是权限 int mkfifo(const char *pathname, mode_t mode); 写入数据 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #incl.
Linux进程通信——管道
DR的专栏
10-13 1640
进程间通信（IPC：Inner Proceeding Communication） 进程是操作系统实现程序独占系统运行的假象的方法，是对处理器、主存、I/O设备的抽象表示。每个进程都是一个独立的资源管理单元，每个进程所看到的是自己独占使用系统的假象，因此各个进程之间是不能够直接的访问对方进程的资源的，不同的进程之间进行信息交互需要借助操作系统提供的特殊的进程通信机制。 进程之间的通信，从物理上
【Linux】进程通信之管道通信详解
阿润菜菜的博客
04-14 6503
详细介绍管道通信的概念和原理、管道通信的实现和应用、管道通信的优化和问题
基本进程通信--文件锁
weixin_33946020的博客
04-01 241
在Linux系统中，进程运行在自己的虚拟内存空间中，如何协调不同虚拟地址空间中的进程访问一个非共享资源，文件加锁是基本进程通信方法之一。 可以使用fcntl()、lockf()、flock()实现文件锁，进而实现进程之间的通信。 1.fcntl() 【函数介绍】 调用形式（执行失败返回-1）： int fcntl(int fd,int cmd); in...
结构体中包含MAP，使用memset清零报错
sinat_26685721的博客
02-16 579
结构体中包含MAP或者list 不能用memset进行清零，否则出现段错误

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值