linux下进程间通信

linux系统下的系统编程-进程间的通信方式

通信方式有三大类A:传统的进程通信方式（无名管道通信，有名管道，信号）B:system V IPC对象（共享内存，消息队列，信号量）C:BSD（套接字），这里笔者只是就目前的学习情况，对传统的通信方式进行总结

无名管道间的通信方式

特点：1只能用于具有亲缘关系的进程之间的通信。2：属于半双工的通信模式，具有固定的读端和写端.3:管道可以看做是特殊的文件，对于他的读写可以使用文件IO如read，write函数

管道是基于文件描述符的通信方式，当一个管道建立时，他会创建两个文件描述符fd[0],fd[1],其中fd[0]固定用于读管道，fd[1]固定用于写管道，这样就构成了一个半双工的通信机制

无名管道的创建函数是pipe，它的函数原型是int pipe(int fd[2]),函数有需要的头文件是#include<unistd.h>,函数的参数是包含两个元素的整形数组，当函数返回值为0时表示成功，返回值为-1时出错

#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.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 create 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 success!\n");
		if(write(pipe_fd[1]," Pipe",5)!=-1)
			printf("parent write2 success!\n");
		close(pipe_fd[1]);
		sleep(3);
		waitpid(pid,NULL,0);
		exit(0);
	}
}

 

注意事项：1：当管道中无数据时，读操作会阻塞。2：向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲的区域，写进程就会试图向管道中写入数据，如果读进程不读走管道缓冲区的数据，那么写操作就会一直阻塞。3：只有在管道的读端存在时，向管道中写入数据才有意义，否则，向管道中写入数据的进程将收到来自内核传来的SIFPIPE信号

 

有名管道FIFO

无名管道只能用于具有亲缘关系的进程之间，这就限制了无名管道的使用范围，而有名管道可以使互不相关的两个进程互相通信，突破了无名管道之间的限制，还有就是，有名管道可以通过路径名来指出，并且在文件系统中可见，进程也可以通过文件IO来操作有名管道，有名管道遵循先进先出的规则，但是不支持lseek()操作

 

有名管道的创建函数是mkfifo,它的函数原型是int mkfifo（const char *filename，mode_t mode）.所需要的头文件有三个#include<unistd.h>,#include<fcntl.h>,#include<sys/types.h>,filename是要创建的管道，mode：指定要创建管道的访问权限，一般用八进制表示，函数返回值为0表示成功，返回值为-1表示失败

示例代码

/*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 "/tmp/myfifo"

main(int argc,char** argv)
{
	int fd;
	char w_buf[100]="hello fifo!!!";
	int nwrite;
//	if(argc<=1)
	printf("Please send something\n");
//	gets(w_buf);

//	strcpy(w_buf,argv[1]);
		
	fd=open(FIFO,O_WRONLY);
	if(fd==-1&&errno==ENXIO)
		{	
			printf("open error; no reading process\n");
			exit(1);
		}
	
	
	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);
		close(fd);
		exit(0);
}

/*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>
#define FIFO "/tmp/myfifo"

main(int argc,char** argv)
{
	char buf_r[100];
	int  fd;
	int  nread;
	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));
	fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);
	if(fd==-1)
	{
		perror("open");
		exit(1);	
	}
	while(1)
	{
		memset(buf_r,0,sizeof(buf_r));
		if((nread=read(fd,buf_r,100))==-1){
			if(errno==EAGAIN)
				printf("no data yet\n");
		}
		printf("read %s from FIFO\n",buf_r);
		sleep(1);
	}	
//	pause();
//	unlink(FIFO);
	close(fd);
	exit(0);
}

linux的信号通信：

信号是在软件基础上对中断机制的一种模拟，是一种异步通信方式，信号可以直接进行用户空间和内核进程之间的交互，内核进程也可以利用它来通知用户空间进程发生了哪些系统事件，如果该进程当前并未处于执行态，则该信号就由内核保存起来，直到该进程恢复执行，再传递给他，如果一个信号背景层设置为阻塞，则该信号的传递被延迟，直到其阻塞被取消时才被传递给进程

用户进程对相好的响应方式：1：忽略信号：対信号不做任何处理，但有两个信号不能忽略，即SIGKILL SIGSTOP 2：捕捉信号，定义信号处理函数，当信号发生时执行相应的处理函数。3：执行缺省操作：linux对每种信号都有默认操作

信号处理的流程

 

使用信号的场合：1：后台进程需要使用信号。2：如果两个进程中没有亲缘关系，无法使用无名管道。3:如果两个进程通信之间只能使用标准输入和标准输出，则无法使用fifo，

其实linux系统中也就是几种信号处理

SIGHUP 含义：（signal hup）该信号在用户终端链接（正常和非正常结束时发出）通常是在终端的控制进程结束时，通知同一会话内的各个作业与控制中断不在关联，默认操作是终止

SIGINT 含义：该信号在用户键（通常是CRTL-C）时发出，终端驱动程序发送此信号送到前台进程中的每一个进程 默认操作是终止

SIGQUT含义：该信号和SIGINT类似，但由QUIT字符（通常是CTRL-\）来控制，默认操作也是终止

SIGILL含义：（signal ill）该信号在一个进程企图执行一条非法指令时（可执行文件本身出现错误，或者师徒执行书籍段，堆栈溢出时）发出，默认操作是终止

SIGFPE含义：（signal fpe）该信号在发生致命的算数运算错误时发出，这里不仅仅包括浮点运算错误，还是包括溢出，除数为零等其他所用的算数的错误默认操作为终止

SIGKILL含义：该信号用来立即结束程序的运行，并且不能被阻塞，处理和忽略。默认操作为终止

SIGALRM含义：该信号当一个定时器到时的时候发出，默认操作是终止    默认为终止

SIGSTOP含义：该信号用于暂停一个进程，却不能被阻塞处理和忽略，   默认为暂停进程

SIGSTP含义：该信号用于暂停交互进程，用户键入susp字符通常是（CTRL-Z）发出这个信号，默认操作是暂停进程

SIGCHLD含义：（signal chld）子进程改变状态时，父进程会收到这个信号   默认操作是忽略

SIGABORT含义：该信号用于结束进程 默认操作是终止

 

信号的发送和捕捉函数 ，kill（）和raise（）

kill（）函数大家熟知的kill系统命令一样，可以发送信号给进程或者是进程组，（实际上，kill系统命令只是kill函数的一个用户接口）。kill()函数的函数原型是int kill（pid_t pid,int sig）;所需的头文件是#include<signal.h>,#include<sys/types.h>,函数返回值为0时表示成功，-1表示函数执行出错

raise（）函数允许 进程向自己发送信号，函数所需的头文件是#include<signal.h>,#include<sys/types.h>,函数原型是int raise(int sig)；函数传入sig信号，成功返回值是0；-1表示函数执行出错

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
	pid_t pid;
	int ret;
	if((pid=fork())<0){
		perror("fork");
		exit(1);
	}
	if(pid == 0){
		raise(SIGSTOP);
		exit(0);
	}
	else{
		printf("pid=%d\n",pid);
		if((waitpid(pid,NULL,WNOHANG))==0){
			if((ret=kill(pid,SIGKILL))==0)
				printf("kill %d\n",pid);
			else{
				perror("kill");
			}
		}
	}
}

信号发送与捕捉   :alarm()和pause()

alarm()也称为是闹钟函数，他可以在进程中设置一个定时器，当定时器指定的时间到时，内核就向进程发送SIGALARM的信号，pause（）函数是用于将调用进程挂起直到收到信号为止

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

int main()
{
        int ret;
        ret=alarm(5);
        pause();
        printf("I have been waken up.\n",ret);
        return 0;
}
    

 

 版权所有，转载请标明链接地址http://www.cnblogs.com/fengdashen

转载于:https://www.cnblogs.com/fengdashen/p/sunshare.html