Linux进程间通信编程

进程间通信方式

现在Linux使用的进程间通信方式包括：

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

2、信号（signal）

3、消息队列

4、共享内存

5、信号量

6、套接字（socket）

1.管道：

管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。

数据被一个进程读出后，将被从管道中删除。进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。

管道包括无名管道和有名管道两种：

前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任意两个进程间的通信。

无名管道——用于父进程和子进程间的通信（有亲缘关系）,随内核持续，内核在，无名管道就在，内核关闭，无名管道消失

1)无名管道

#include <unistd.h>

int pipe(int filedis[2])；

当一个管道建立时，它会创建两个文件描述符：

filedis[0] 用于读管道， filedis[1] 用于写管道

通常先创建一个管道，再通过fork函数创建一个子进程，该子进程会继承父进程所创建的管道。

实例：父进程写，子进程读

 1 #include <stdio.h>                                                                                                                                                                                                                                                                                            
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <errno.h>
  5 #include <sys/types.h>
  6 #include <memory.h>
  7 #include <sys/wait.h>
  8 
  9 int main()
 10 {
 11     int pipe_fd[2];   //创建管道
 12     pid_t pid;
 13 
 14     char buf_r[100];
 15     char *p_wbuf;
 16     int r_num;
 17 
 18     memset(buf_r,0,sizeof(buf_r));
 19 
 20     if(pipe(pipe_fd) < 0)
 21     {
 22         printf("pipe create error!\n");
 23         return -1;
 24     
 25     }
 26     pid = fork();  //创建进程
 27     if(pid  ==  0)
 28     {
 29         printf("\n");
 30         close(pipe_fd[1]);  //子进程关闭写通道
 31         sleep(2);
 32 
 33         if((r_num = read(pipe_fd[0],buf_r,100))  > 0)//子进程读取管道
 34         {
 35 
 36             printf("%d numbers read from the pipe is %s\n",r_num,buf_r);
 37         }
 38         close(pipe_fd[0]); //子进程关闭读通道
 39         printf("child\n");
 40         _exit(0);
 41     }
 42     else if(pid > 0)
 43     {
 44         close(pipe_fd[0]); //父进程关闭读通道
 45 
 46         if(write(pipe_fd[1],"hello",5) != -1)//父进程写数据
 47             printf("parent write success!\n");
 48         if(write(pipe_fd[1],"Pipe",4) != -1)
 49             printf("parent write success!\n");
 50 
 51         close(pipe_fd[1]);//父进程关闭写通道
 52         sleep(2);
 53         waitpid(pid,NULL,0);   //等待子进程完成
 54     }
 55 
 56     return 0;
 57 }

必须在系统调用fork( )前调用pipe( )，否则子进程将不会继承文件描述符。

2)有名管道 

有名管道和无名管道基本相同，但也有不同点：无名管道只能由父子进程使用；但是通过命名管道，不相关的进程也能交换数据。

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char * pathname, mode_t mode)

pathname：FIFO文件名 mode：属性

一旦创建了一个FIFO，就可用open打开它，一般的文件访问函数（close、read、write等）都可用于FIFO。

2.信号(signal)机制

1）信号产生

 1、当用户按某些按键时，产生信号   

 2、硬件异常产生信号：除数为0、无效的存储 访问等等。这些情况通常由硬件检测到，将其通 知内核，然后内核产生适当的信号通知进程，例 如，内核对正访问一个无效存储区的进程产生一 个SIGSEGV信号    

 3、进程用kill函数将信号发送给另一个进程      

4、用户可用kill命令将信号发送给其他进程

2）常见信号（kill -l）

§ SIGHUP： 从终端上发出的结束信号

§ SIGINT： 来自键盘的中断信号（Ctrl-C）

§ SIGKILL：该信号结束接收信号的进程

§ SIGTERM：kill 命令发出的信号

§ SIGCHLD：标识子进程停止或结束的信号

§ SIGSTOP：来自键盘（Ctrl-Z）或调试程序的停止执行信号 

3）信号处理

1、忽略此信号，大多数信号都按照这种方式进行处理，但有两种信号却决不能被忽略,它们是：SIGKILL\SIGSTOP。这两种信号不能被忽略的原因是：它们向超级用户提供了一种终止或停止进程的方法

2、执行用户希望的动作，通知内核在某种信号发生时，调用一个用户 函数。在用户函数中，执行用户希望的处理

3、执行系统默认动作，对大多数信号的系统默认动作是终止该进程

4）信号发送（kill，raise）

（1）kill——既可以向自身发送信号，也可以向其他进程发送信号

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int signo)

kill的pid参数有四种不同的情况：

1、pid>0    将信号发送给进程ID为pid的进程。

2、pid == 0    将信号发送给同组的进程。

3、pid < 0    将信号发送给其进程组ID等于pid绝对值的进程。

4、pid ==－1     将信号发送给所有进程。

（2）raise——只可以向进程自身发送信号

#include <sys/types.h>
#include <signal.h>
int raise(int signo)

 实例：子进程通过raise给自己发送停止信号，父进程给子进程发送杀死信号。

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

int main()
{
	pid_t pid;
	int ret;
	if((pid=fork())<0)
	{
		perror("fork error");
	}
	else if (pid==0)//子进程
	{
		raise (SIGSTOP);//子进程先停止，不代表结束
	}
	else
	{
		printf("pid =%d\n",pid);//子进程id

		if(waitpid(pid,NULL,WNOHANG)==0)//非阻塞等待
		{
			if((ret=kill(pid,SIGKILL))==0)//父进程杀死子进程
			{	
				printf("killed %d\n",pid);
			}
			else
			{
				perror("kill error");
			}
		}	
	}
	
		return 0;
}

 

（3）alarm

使用alarm函数可以设置一个时间值(闹钟时间)，当所设置的时间到了时，产生SIGALRM信号.如果不捕捉此信号，则默认动作是终止该进程

#include <unistd.h>
unsigned int alarm(unsigned int seconds)
Seconds：经过了指定的seconds秒后会产生信号SIGALRM。

• 每个进程只能有一个闹钟时间.如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换
• 如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟）

 （4）pause

pause函数使调用进程挂起直至捕捉到一个信号。

#include <unistd.h>
int pause(void)
只有执行了一个信号处理函数后，挂起才结束
出错返回-1

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

int main()
{
	int ret;
	ret =alarm(5);//启动定时器进行工作，但是程序不会等其工作结束
	printf("I have been waken up!\n");
	
	alarm(2); //会覆盖前面的5s 
	pause();//进程挂起,直到接收到下一个信号才让进程执行
	return 0;
}

（5）信号处理

当系统捕捉到某个信号时，可以忽略该信号或是使用指定的处理函数来处理该信号，或者使用系统默认的方式

信号处理的主要方法有两种，一种是使用简单的signal函数，另一种是使用信号集函数组

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
第一个参数signum：指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。 　 
第二个参数handler：描述了与信号关联的动作，它可以取以下三种值： 
SIG_IGN：忽略此信号
SIG_DFL: 按系统默认方式处理
信号处理函数名：使用该函数处理

（1）SIG_IGN(忽略)

#include <stdio.h>
#include <signal.h>
int main(int argc, char *argv[]) 
{
    signal(SIGINT, SIG_IGN);
    while(1);
    return 0;
}
SIGINT信号代表由InterruptKey产生，通常是CTRL +C 或者是DELETE 。
执行上述代码时，按下CTRL + C程序没有反应。
这就对了，如果我们想结束该程序可以按下CTRL +\来结束。
当我们按下CTRL +\组合键时，产生了SIGQUIT信号，此信号并没有被忽略。

（2）SIF_DFL(按系统默认方式处理)

#include <stdio.h>
#include <signal.h>
int main(int argc, char *argv[]) {
    signal(SIGINT, SIG_DFL);
    while(1);
    return 0;
}
这时就可以按下CTRL +C 来终止该进程了。
把signal(SIGINT, SIG_DFL);这句去掉，效果是一样的

（3）sighandler_t类型的函数指针 　

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

此函数必须在signal()被调用前申明，handler中为这个函数的名字。
当接收到一个类型为sig的信号时，就执行handler 所指定的函数。
（int）signum是传递给它的唯一参数。执行了signal()调用后，进程只要接收到类型为sig的信号，不管其正在执行程序的哪一部分，就立即执行func()函数。当func()函数执行结束后，控制权返回进程被中断的那一点继续执行。

实例1： 

#include <stdio.h>
#include <signal.h>
typedef void (*signal_handler)(int);
 
void signal_handler_fun(int signum) {
    printf("catch signal %d\n", signum);
}
 
int main(int argc, char *argv[]) {
    signal(SIGINT, signal_hander_fun);
    while(1);
    return 0;
}

按下ctrl+c后，中断，函数接受到信号后执行函数，ctrl+z结束程序运行。

实例2：

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

void my_func(int sign_no)
{
	if(sign_no==SIGINT)
		printf("hello world\n");
	else if(sign_no==SIGQUIT)
	{
		printf("eixt!\n");
		exit(1);
	}
}
int main()
{
	pid_t pid;


	pid = fork();


	if(pid == 0)
	{
	    printf("Waiting for signal SIGINT or SIGQUIT \n ");
	
	    /*注册信号处理函数*/
	    signal(SIGINT, my_func);
	    signal(SIGQUIT, my_func);
	
	     pause();
	}
	if(pid > 0)
	{
		int cmd;

		scanf("%d",&cmd);


		if(cmd == 1)
		{
			kill(pid,SIGINT);
		}

		if(cmd == 2)
		{
			kill(pid,SIGQUIT);
		}
    } 
}

 

 实例3：

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

void func(int signo)
{
	if(signo == SIGALRM)
	{
		printf("signal is SIGALRM!\n");
	}
}

int main()
{
	int ret;


	ret = alarm(5);

	signal(SIGALRM,func);

	pause();



	printf("i have been waken up!\n");

    return 0;
}

3.共享内存

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

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

• ②映射

• char * shmat ( int shmid, char *shmaddr, int flag)
  • 参数
    • shmid：shmget函数返回的共享存储标识符
    • flag：决定以什么方式来确定映射的地址（通常为0）
  • 返回值：
    • 如果成功，则返回共享内存映射到进程中的地址
    • 如果失败，则返回- 1
• ③使用
• ④解除映射
  • int shmdt ( char *shmaddr )

• ⑤shmctl删除

1.ftok函数生成键值

每一个共享存储段都有一个对应的键值（key）相关联（消息队列、信号量也同样需要）。

所需头文件：#include<sys/ipc.h>

函数原型 ：key_t ftok(const char *path ,int id);

path为一个已存在的路径名

id为0~255之间的一个数值，代表项目ID，自己取

返回值：成功返回键值（相当于32位的int）。出错返回-1

例如：key_t key = ftok( “/tmp”, 66);

2.shmget函数创建共享存储空间并返回一个共享存储标识符

所需头文件：#include<sys/shm.h>

函数原型： int shmget(key_t key, size_t size,int flag);

key为ftok生成的键值

size为共享内存的长度，以字节为单位

flag为所需要的操作和权限，可以用来创建一个共享存储空间并返回一个标识符或者获得一个共享标识符。

flag的值为IPC_CREAT：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空间，并返回一个

共享存储标识符。如果存在，则直接返回共享存储标识符。

flag的值为 IPC_CREAT | IPC_EXCL：如果不存在key值的共享存储空间，且权限不为0，则创建共享存储空

间，并返回一个共享存储标识符。如果存在，则产生错误。

返回值：成功返回共享存储ID；出错返回-1

例如：int id = shmget(key,4096,IPC_CREAT|IPC_EXCL|0666);创建一个大小为4096个字节的权限为0666（所有用户可读可写，具体查询linux权限相关内容）的共享存储空间，并返回一个整形共享存储标识符，如果key值已经存在有共享存储空间了，则出错返回-1。

int id = shmget(key,4096,IPC_CREAT|0666);创建一个大小为4096个字节的权限为0666（所有用户可读可写，具体查询linux权限相关内容）的共享存储空间，并返回一个共享存储标识符，如果key值已经存在有共存储空间了，则直接返回一个共享存储标识符。

3.shmat函数获取第一个可用共享内存空间的地址

所需头文件：#include<sys/shm.h>

函数原型： void *shmat(int shmid, const void addr, int flag);shmid为shmget生成的共享存储标识

符addr指定共享内存出现在进程内存地址的什么位置，直接指定为NULL让内核自己决定一个合适的地址位置

flag为对数据的操作，如果指定为SHM_RDONLY则以只读方式连接此段，其他值为读写方式连接此段。翻阅

linux下shm.c文件得到#define SHM_RDONLY      010000  / read-only access */

返回值：成功返回指向共享存储段的指针；错误返回-1（打印出指针的值为全F） 

例如：char *addr  = shmat(id, NULL, 0);就会返回第一个可用的共享内存地址的指针的值给addr

4.shmdt函数进行分离

当不需要对此共享内存进行操作时候，调用shmdt函数进行分离，不是删除此共享存储空间哟。

所需头文件：#include

函数原型： int shmdt(const void *addr);

addr为shmat函数返回的地址指针

返回值：成功返回0；错误返回-1

例如：int ret = shmdt(addr);

5.shmctl函数对共享内存进行控制

简单的操作就是删除共享存储空间了，也可以获取和改变共享内存的状态

• 所需头文件：#include
• 函数原型：int shmctl(int shmid, int cmd, struct shmid_ds *buf);
  • shmid就是shmget函数返回的共享存储标识符
  • cmd有三个，常用删除共享内存的为

• IPC_STST:获取这个结构体的值IPC_STAT：得到共享内存的状态，把共享内存的shmid_ds结构复制到buf中；
• IPC_RMID；
• IPC_SET：改变共享内存的状态，把buf所指的shmid_ds结构中的uid、gid、mode复制到共享内存的shmid_ds结构内。（内核为每个共享存储段维护着一个结构，结构名为shmid_ds，这里就不讲啦，里面存放着共享内存的大小，pid，存放时间等一些参数）

• • buf就是结构体shmid_ds
  • 返回值：成功返回0；错误返回-1
• 例如：int ret = shmctl(id, IPC_RMID,