Linux编程学习笔记：进程间通信（管道、信号、共享内存）

最新推荐文章于 2024-04-17 16:43:37 发布
最新推荐文章于 2024-04-17 16:43:37 发布
阅读量1.9k 收藏 3
点赞数 2
分类专栏： Linux编程 Linux学习 文章标签： Linux 进程间通信 嵌入式 C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a568713197/article/details/86743583
版权

一、概述

    目的

    1、数据传输

    2、资源共享

    3、通知事件

    4、进程控制

    Linux进程间通信（IPC）由几步发展而来：UNIX进程间通信、基于System V进程间通信、POSIX进程间通信

    POSIX

        可移植操作系统接口，最初是为了提高UNIX环境下应用程序的可移植性，然而POSIX并不局限于LINUX，其他许多操作系统，例如DEC OpenVMS和Windows都支持POSIX标准

    System V

        也被称为AT&T System V，是Unix操作系统众多版本中的一支

    通信方式

        管道（pipe）和有名管道（FIFO）

        信号（signal）

        消息队列

        共享内存

        信号量

        套接字

二、管道通信

    特点：单向、先进先出，一个进程的输出与一个进程的输入连接在一起，一个进程（写进程）在管道尾部写入数据，另一个进程（读进程）在管道头部读出数据

    无名管道、有名管道：前者用于父进程和子进程间的通信，后者可以用于同一系统中任意两个进程间的通信

    无名管道

        创建：int pipe(int fledis[2]);

        当一个管道建立时，它会创建两个文件描述符：filedis[0]用于读管道。filedis[1]用于写管道

        关闭：使用close

#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int pipe_fd[2];
	if(pipe(pipe_fd)<0)
	{
		printf("pipe create error\n");
		return -1;
	}
	else
		printf("pipe create success\n");
	close(pipe_fd[0]);
	close(pipe_fd[1]);
}

        运行结果

[gyy@localhost process_com]$ gcc pipe_creat.c -o pipe_creat

[gyy@localhost process_com]$ ./pipe_creat

pipe create success

    读写：管道用于不同进程间通信，通常会先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道（必须在调用fork之前调用pipe()，否则子进程将不会继承文件描述符）

#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

int main()
{
	int pipe_fd[2];
	pid_t pid;
	char buf_r[100];
	char *p_wbuf;
	int r_num;
	
	memset(buf_r,0,sizeof(buf_r));
	
	//创建管道
	if(pipe(pipe_fd)<0)
	{
		printf("pipe creat error!\n");
		return -1;
	}
	//创建子进程
	if((pid=fork())==0)
	{
		printf("\n");
		close(pipe_fd[1]);
		sleep(2);
		if((r_num=read(pipe_fd[0],buf_r,100))>0)
		{
			printf("%d numbers read from the pipe is: %s\n",r_num,buf_r);
		}	
		close(pipe_fd[0]);
		exit(0);
	}
	else if(pid>0)
	{
		close(pipe_fd[0]);
		if(write(pipe_fd[1],"Hello",5)!=-1)
			printf("parent write1 hello!\n");
		if(write(pipe_fd[1],"Pipe",5)!=-1)
			printf("parent write2 Pipe!\n");
		close(pipe_fd[1]);
		sleep(3);
		waitpid(pid,NULL,0);
		exit(0);	
	}
}

        运行结果：首先创建管道，然后创建子进程，子进程会继承父进程的管道，子进程首先关闭写等待2秒，然后读出管道中的信息并打印，父进程关闭读然后依次写入“Hello”“Pipe”，然后睡眠3秒

[gyy@localhost process_com]$ gcc pipe_rw.c -o pipe_rw

[gyy@localhost process_com]$ ./pipe_rw

parent write1 hello!

parent write2 Pipe!

10 numbers read from the pipe is: HelloPipe

 

    命名管道（FIFO）

        不相关的进程也能交换数据，实质上就是文件

        创建：int mkfifo(const char *pathname,mode_t mode)

            pathname:FIFO文件名

            mode：属性，见文件操作

        当打开FIFO时，非阻塞标志（O_NONBLOCK ）将对以后产生如下影响

            1、没有使用O_NONBLOCK：访问要求无法满足时进程将阻塞

            2、使用O_NONBLOCK：访问要求无法满足是不阻塞，立刻出错返回，errno是ENXIO

        fifo_write.c

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FIFO_SERVER "/tmp/myfifo"

main(int argc,char **argv)
{
	int fd;
	char w_buf[100];
	int nwrite;
	//打开FIFO
	fd=open(FIFO_SERVER,O_WRONLY|O_NONBLOCK,0);
	if(argc==1)
	{
		printf("Please send something\n");
		exit(-1);
	}
	if(fd==-1)
		printf("OPEN ERROR\n");
	strcpy(w_buf,argv[1]);
	printf("%s\n",w_buf);
	if((nwrite=write(fd,w_buf,100))==-1)
	{
		if(errno==EAGAIN)
			printf("The FIFO has not been read yet.Please try later\n");
	}
	else
		printf("write %s to the FIFO\n",w_buf);
	
}

        fifo_read.c

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#define FIFO "/tmp/myfifo"

main(int argc,char ** argv)
{
	char buf_r[100];
	int fd;
	int nread;
	//创建FIFO
	if(mkfifo(FIFO,O_CREAT|O_EXCL)<0&&(errno!=EEXIST))
		printf("cannot create fifoserver\n");
	printf("Preparing for reading bytes...\n");
	
	memset(buf_r,0,sizeof(buf_r));
	//打开FIFO
	fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);
	if(fd==-1)
	{
		perror("open");
	}
	while(1)
	{
		memset(buf_r,0,sizeof(buf_r));
		if((nread=read(fd,buf_r,100))==-1)
		{
			if(errno=read(fd,buf_r,100)==-1)
			{
				if(errno==EAGAIN)
					printf("no date yet\n");	
			}
		}
		printf("read %s from FIFO\n",buf_r);
		sleep(1);
	}
	//暂停等待信号
	pause();
	//删除文件
	unlink(FIFO);
}

        运行结果

[root@localhost process_com]# gcc fifo_write.c -o fifo_write

[root@localhost process_com]# gcc fifo_read.c -o fifo_read

fifo_read.c

[root@localhost process_com]# ./fifo_read

Preparing for reading bytes...

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read FIFO_TEST from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

read  from FIFO

^C

fifo_write.c

[root@localhost process_com]# ./fifo_write FIFO_TEST

FIFO_TEST

write FIFO_TEST to the FIFO

        注意要两个进程同时运行

三、信号

    信号（signal）机制是UNIX系统中最为古老的进程间通信机制

    硬件软件都能产生信号

    进程用kill函数将信号发送给另一个进程，用户可用kill命令将信号发送给其他进程

    几种常见的信号

        

    信号处理

    1、忽略信号

        大多数信号都按照这种方式处理，但是SIGKILL、SIGSTOP不能忽略

    2、执行用户希望的动作

        通知内核在某种信号发生时调用一个用户函数

    3、执行系统默认动作

       大多数信号默认动作是结束进程

    信号发送

        kill和raise

        kill既可以向自身发送信号，也可以向其他进程发送信号，raise函数是向进程自身发送信号

        int kill(pid_t pid,int signo)

        int raise(int signo)

        alarm函数用于指定一段时间后产生一个SIGALRM信号，如果不捕捉此信号，默认动作是终止该进程

        unsigned int alarm(usigned int seconds)

        每个进程只能有一个闹钟时间，如果在调用alarm时已设置过alarm，则时间被替代

        设置闹钟时间为0则取消以前的闹钟

    Pause

        pause函数使进程挂起直至捕获到一个信号
        int pause(void)

    信号的处理

        方法：使用简单的signal函数，使用信号集函数组

    信号响应函数signal

        void (*signal (int signo,viod (*func)(int)))(int)

        

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>


void my_func(int sign_no)
{
	if(sign_no==SIGINT)
		printf("I have get SIGINT\n");
	else if(sign_no==SIGQUIT)
		printf("I have get SIGQUIT\n");
}

int main()
{
	printf("Waiting for signal SIGINT or SIGQUIT\n");
	//注册新号处理函数
	signal(SIGINT,my_func);
	signal(SIGQUIT,my_func);

	pause();
	exit(0);
}

    运行结果

[root@localhost process_com]# gcc mysignal.c -o mysignal
[root@localhost process_com]# ./mysignal 
Waiting for signal SIGINT or SIGQUIT
I have get SIGQUIT
[root@localhost process_com]# ps au | grep ./mysignal
root       7563  0.0  0.0   4212   356 pts/1    S+   17:08   0:00 ./mysignal
[root@localhost process_com]# kill -s SIGQUIT 7563
[root@localhost process_com]# ps au | grep ./mysignal
root       7566  0.0  0.0   4212   356 pts/1    S+   17:09   0:00 ./mysignal
[root@localhost process_com]# kill -s SIGINT 7566
[root@localhost process_com]# ./mysignal 
Waiting for signal SIGINT or SIGQUIT
I have get SIGINT

    代码分析：my_func为信号的处理函数，参数为某一个信号，可以根据信号的不同有不同的打印值，主程序为SIGINT和SIGQUIT注册，然后pause等待信号。这是打开另外一个中断，先查阅进程PID，然后用kill指令发送信号，然后程序进程就会捕获信号。

四、共享内存

    被多个进程共享的一部分物理内存，共享内存是进程间共享数据的一种最快的方式，一个进程向共享内存区域写了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容

    

    

    两个步骤：

    1、创建共享内存，使用shmget函数

    2、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数

    创建

        int shmget(key_t key,int size,int shmflg)

        key标识共享内存的键值：O/IPC_PRIVATEO当key的取值为IPC_PRIVATE,则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置 IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。

        返回值：如果成功，返回共享内存标识符；如果失败，返回-1。

    映射

        key标识共享内存的键值：O/IPC_PRIVATEO当key的取值为IPC_PRIVATE,则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中又设置 IPC_PRIVATE这个标志，则同样会创建一块新的共享内存。返回值：如果成功，返回共享内存标识符；如果失败，返回-1。

        int shmat(int shmid,char *shmaddr,int flag)

        shmid：shmget函数返回的共享存储标识符

        flag：决定以什么方式来确定映射的地址（通常为0）

        shmaddr写零系统自动指定

        返回值：如果成功，则返回共享内存映射到进程中的地址，失败返回-1

    脱离

        int shmdt(char * shmaddr)

        不在需要共享内存使需要把它从进程地址空间中脱离

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define PERM S_IRUSR|S_IWUSR

int main(int argc,char **argv)
{
	int shmid;
	char *p_addr,*c_addr;
	if(argc!=2)
	{
		fprintf(stderr,"Usage:%s\n\a",argv[0]);
		exit(1);
	}
	if((shmid=shmget(IPC_PRIVATE,1024,PERM))==-1)
	{
		fprintf(stderr,"Create Share Memory Error: %s\n\a",strerror(errno));
		exit(1);
	}
	//创建子进程
	if(fork())//父进程写
	{
		p_addr=shmat(shmid,0,0);
		memset(p_addr,'\0',1024);
		strncpy(p_addr,argv[1],1024);
		wait(NULL);//释放资源，不关心终止情况
		exit(0);
	}
	else	//子进程读
	{
		sleep(1);
		c_addr=shmat(shmid,0,0);
		printf("Client get: %s\n",c_addr);
		exit(0);
	}
}

    运行结果

[root@localhost process_com]# gcc shmem.c -o shmem
[root@localhost process_com]# ./shmem SHMEM_Test
Client get: SHMEM_Test

    代码分析：创建共享内存，创建子进程后父进程在映射后给共享内存区域写‘\0’（结束符），然后把参数写入共享内存区域，子进程先休眠1秒，等待父进程写完毕，然后映射共享内存，读出其中的数据并打印。

爱吃肉的大高个
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统编程：fifo有名管道的使用
重庆李四
03-20 410
fifo介绍我们可以利用管道进行进程间通信，已经有匿名管道 为啥还要fifo 有名管道呢？有名管道是对匿名管道的一个补充，匿名管道是用在有血缘关系的进程间通信。fifo有名管道呢，可以用在任何进程间通信。函数原型 int mkfifo(const char *pathname, mode_t mode);第一个参数是匿名管道的路径，第二个参数创建有名管道的权限。当然man 手册是最好的文档，一定要...
LINUX学习笔记14——进程间通信3共享内存
小鱼的专栏
12-06 322
a)         意义：多个进程共享一部分物理内存。访问快，方便 b)         先创建共享内存：int shmget(key_t key, int size, int shmflg) 1.         Key：标志共享内存的键值；0/IPC_PRIVATE a)         Key=0：本不创建，但若shmflg仍为IPC_PRIVATE则仍创建 2.
【Linux】进程间通信 -- 共享内存
最新发布
m0_68146877的博客
04-17 945
ftok() 函数使用给定的路径 命名文件标识(必须引用一个现有的，可访问的文件)和 proj_id 的最低 8 位(必须为非零)来生成 key_t 类型的 System V IPC 密钥，适合用于 msgget(2)， semget(2)，或 shmget(2)。它可以用于获取先前创建的共享内存的标识符(在 shmflg 为 0且 key 的值没有 IPC_PRIVATE时)，也可以用于创建一个新的集合。当使用相同的 proj_id 值时，对于命名相同文件的所有路径名，结果值是相同的。
Linux下进程间通信 之 共享内存同步方法(互斥锁，信号量 和 信号)
12-15 7891
先说结论：使用的还是，“互斥锁”，“信号量” 和 “信号” 进行同步。 ========================================================================= 以下为转载部分：linux实现共享内存同步的四种方法_sunxiaopengsun的专栏-CSDN博客_共享内存同步机制 ——————————————————————————————————————————— 同步(synchronization)指的是多个任务(线程...
【Linux进程间通信】共享内存
aoeaoao的博客
11-21 385
【Linux进程间通信】共享内存
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存
爱的海洋
04-19 857
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存 参考：《linux编程从入门到精通》,《Linux C程序设计大全》,《unix环境高级编程》 参考：C和指针学习 说明：本文非常的长，也是为了便于查找和比较，所以放在一起了 Linux 传统的进程间通信有很多，如各类管道、消息队列、内存共享、信号量等等。但它们都无法介于内核态与用户态使用，原因如表 通信方法 无法介于...
linux-note:《 LinuxUnix系统编程手册》笔记
03-11
6. **进程间通信**：理解各种IPC机制，如管道（Pipe）、命名管道（FIFO）、共享内存和消息队列。分析它们的优缺点及适用场景，以及如何通过这些机制实现进程间的协调与数据交换。 7. **权限与安全**：深入理解用户...
UNIX系统编程学习笔记
06-15
5. **进程间通信（IPC）**：包括管道（pipe）、FIFO、套接字（socket）以及共享内存、消息队列等，这些都是进程间交换数据的方式。 6. **权限与文件属性**：每个文件都有所有者、组和其他用户的读、写、执行权限。`...
Linux多线程编程_linux多线程_Linux多线程；应用笔记_columnc9g_
10-03
这使得线程间通信更为便捷，同时也增加了编程的复杂性。 在Linux多线程编程中，我们通常使用POSIX线程库（pthread），它提供了跨平台的线程创建、同步和通信功能。下面是一些关键知识点： 1. **线程创建**：...
python学习笔记之多进程
09-16
需要注意的是，多进程并不总是比单进程更快，因为进程间通信（IPC）和进程创建销毁都会带来一定的开销。此外，由于每个进程都有自己的内存空间，数据共享需要借助额外的机制如管道、队列等，这也增加了编程复杂性。...
c.zip_Linux/Unix编程_Unix_Linux_
08-11
2. **进程管理**：包括进程创建（fork）、进程间通信（IPC，如管道、信号量、消息队列、共享内存等）以及进程调度。PV操作就是利用了管道这一IPC机制。 3. **文件系统**：理解I/O操作，如打开、读取、写入和关闭...
使用命名管道实现进程通信
G453473123的博客
05-17 1463
实验四：使用命名管道实现进程通信 一、实验目的 了解windows系统环境下的进程通讯机制。 熟悉Windows系统提供的进程通信API。 二、实验准备 相关API函数介绍 建立命名管道 函数CreateNamePipe（）创建一个命名管道实例，并返回该管道的句柄。 原型： HANDLE CreateNamePipe（ LPCTSTR lpName， //命名管道的名字 DWORD dwOpenMode， /
【操作系统原理】使用管道完成进程间通信（匿名管道pipe、命名管道fifo）
热门推荐
野心家-Andy的博客
04-28 1万+
        我们先来说说进程间通信（IPC）的一般目的，大概有数据传输、共享数据、通知事件、资源共享和进程控制等。但是我们知道，对于每一个进程来说这个进程看到属于它的一块内存资源，这块资源是它所独占的，所以进程之间的通信就会比较麻烦，原理就是需要让不同的进程间能够看到一份公共的资源。所以交换数据必须通过内核,在内核中开辟一块缓冲区，进程1把数据从用户空间 拷到内核缓冲区，进程2再从内核缓冲区把...
Linux进程间通信
xp55699312的专栏
03-28 1032
Linux进程间通信一、进程间通信概述进程通信有如下一些目的：A、数据传输：一个进程需要将它的数据发送给另一个进程，发送的数据量在一个字节到几M字节之间B、共享数据：多个进程想要操作共享数据，一个进程对共享数据的修改，别的进程应该立刻看到。C、通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。D、资源共享：多个进程之间共享同样的资源。为了作
linux进程间通信之共享内存
weixin_50374599的博客
11-04 799
linux进程间通信，共享内存
进程间通信的简单示例-管道+信号
weixin_43476621的博客
11-20 550
要求 利用管道技术实现父子进程间通信，父进程以3秒为周期接收用户输入并发送到子进程，子进程接收到信息后显示并回传，父进程接收到回传信息后显示。父子进程在通信过程中采用信号中断处理方式进行处理，接收到“exit”字符串后父子进程均退出 想法 两个pipe分别代表“父->子”、“子->父”的通信 利用SIGALRM信号定时以3s为周期接收用户输入并将数据放入"父->子"pipe 父进程放入数据后发送SIGUSR2信号通知子进程，子进程捕捉后读取 子进程读取成功后发送SIGUSR2信号通知父进
Linux创建子进程的具体过程
shazhoulada1的专栏
04-09 3255
黄志恒 原创作品转载请注明出处 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 这篇文章来分析Linux操作系统创建一个子进程的具体流程。本文设计的Linux操作系统基于Linux-3.18.6内核，实验环境又实验楼提供，地址：http://www.shiyanlou.com/courses/195。再次感谢孟老
关于Windows创建进程的过程
jiangqin115的专栏
11-21 5376
1. 程序的启动 当我们通过explorer.exe运行一个程序时，explorer.exe会调用CreateProcess函数请求系统为这个程序创建进程。当然，其它程序也可以调用CreateProcess函数创建进程。 系统在为进程分配内部资源，建立独立的地址空间后，会为进程创建一个主线程。我们可以把进程看作单位，把线程看作员工。进程拥有资源，但真正在CPU上运行和调度的是线程。系统
创建共享内存后，进程结束，共享内存是否会消失？
a13602955218的博客
04-05 3764
不会。 进程间通信使用的数据结构:管道、socket、共享内存、消息队列、信号量等，是属于内核级的，一旦创建后就由内核管理，若进程不对其主动释放，那么这些变量会一直存在，除非重启系统。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值