linux进程间通信程-pipe、mkfifo、…

进程间通信概述：

目的：

1、数据传输：一个进程需要将它的数据发送给另一个进程。

2、资源共享：多个进程之间共享同样的资源。

3、通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。

4、进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。

linux进程间通信（IPC）由以下几个部分发展而来：

1、unix进程间通信

2、基于system v进程间通信

3、posix进程间通信

posix(portable operating system interface)表示可移植操作系统接口。电气和电子工程师协会（institute of electrical and electronics engineers, IEEE）最初开发POSIX标准，是为了提高UNIX环境下应用程序的可移植性。然而，POSIX并不局限于UNIX，许多其它的操作系统，例如DEC openVMS 和 Microsoft Windows，都支持POSIX标准。

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

 

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

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

2、信号（signal）

3、消息队列

4、共享内存

5、信号量

6、套接字（socket）

 

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

数据被一个进程读出后，将被从管道中删除，其它读进程将不能再读到这些数据。管道提供了简单的流控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。

 

管道包括无名管道和有名管道两种，前者用于父进程和子进程间的通信，后者可用于运行于同一系统中的任何两个进程间的通信。

无名管道由pipe（）函数创建：

int pipe(int filedis[2]);

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

 

管道的关闭只需要将两个文件描述符关闭即可，可以使用普通的close函数逐个关闭。

例：pipe.c

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

int main(void)
{
int pipe_fd[2];
if(pipe(pipe_fd) < 0)//pipe创建管道成功就会返回0.否则就会返回-1.
{
printf("pipe create error\n");
return -1;
}
else
printf("pipe create success\n");
close(pipe_fd[0]);
close(pipe_fd[1]);

return 0;
}

 

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

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

例：pipe_rw.c

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

int main(void)
{
int pipe_fd[2];
pid_t pid;
char buf_r[100];
char *p_wbuf;
int r_num;

memset(buf_r, 0, sizeof(buf_r));

//申请一块内存并进行初始化，详细可参考：

http://cache.baiducontent.com/c?m=9d78d513d99d1ae812fa950e1a67a371685497624c88874a3e83d55cd424054e1d20a5f930236319ce95223a54b8492bbbb1602e200357ebcc8e951b8ce5c96c788b23367301d501548848f19c5b739666c301b7ee04e2b0f43996a4d5&p=8e759a46d7c916eb0be2966d7f0c8c&newp=9e769a479e934eac59e78f6d515e93231610db2151dcda5d&user=baidu&fm=sc&query=liux��memset&qid=&p1=1

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 hello!\n");
if(write(pipe_fd[1], "pipe", 5) != -1)
printf("parent write2 pipe!\n");
close(pipe_fd[1]);
}
return 0;
}

 

运行结果：

[regry@campusnetwork test]$ ./pipe_rw

parent write1 hello!
parent write2 pipe!

[regry@campusnetwork test]$ 10 numbers read from the pipe is hellopipe

 

命名管道（FIFO）：

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

# 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。

当打开FIFO时，非阻塞标志（O_NONBLOCK）

1、没有使用O_NONBLOCK:访问要求无法满足时进程将阻塞。如试图读取空的FIFO，将导致进程的阻塞。

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

例：fifo_w.c和fifo_r.c

//fifo_w.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 "/home/regry/test/myfifo"

int main(int argc, char **argv)
{
int fd;
char w_buf[100];
int nwrite;

fd = open(FIFO_SERVER, O_WRONLY | O_NONBLOCK, 0);

if(argc == 1)
{
printf("please send something\n");
exit(-1);
}

strcpy(w_buf, argv[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);

return 0;
}

//fifo_r.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 "/home/regry/test/myfifo"

int main(int argc, char *argv)
{
char buf_r[100];
int fd;
int nread;
//build fifo
if((mkfifo(FIFO, O_CREAT | O_EXCL) < 0) && (errno != EEXIST))
printf("cannot creat fifoserver\n");

printf("preparing for reading bytes...\n");

memset(buf_r, 0, sizeof(buf_r));

//open fifo
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);//delete file
return 0;
}
不同进程间通过有名管道通信，例子如上所示，本人在编译的过程中出了点问题，留在以后解决。

 

信号通信：信号（signal）机制是unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：

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

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

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

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

 

下面是几种常见的信号类型：

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

SIGINT：来自键盘的中断信号（ctrl-c）

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

SIGTERM：kill命令发出的信号

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

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

 

信号处理：

当某信号出现时，将按照下列三种方式中的一种进行处理：

1、忽略此信号

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

2、执行用户希望的动作

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

3、执行系统默认动作

对大多数信号的系统默认动作是终止该进程。

 

信号发送：

发送信号的主要函数有kill和raise。

区别：

kill可以向自身发送信号，也可向其他进程发送信号。与kill函数不同的是，raise是向进程自身发送信号。

# include <sys/types.h>

# include <signal.h>

int kill(pid_t pid, int signo)

int raise(int signo)

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

1、pid > 0

将信号发送给进程ID为pid的进程。

2、pid == 0

将信号发送给同组的进程。

3、pid < 0

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

4、pid == -1

将信号发送给所有进程。

kill中的signo：准备发送的信号代码，如果为0则没有任何信号送出，但系统会执行错误检查，通常会利用signo值为零来检测某个进程是否仍在执行。

返回值说明：成功执行时，返回0.失败返回-1，errno被设为以下某个值：EINVAL:指定的信号码无效（参数signo不合法）。EPERM：权限不够无法发送信号给指定进程。ESRCH:参数pid所指向的进程或进程组不存在。

 

Alarm

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

# include <unistd.h>

unsigned int alarm(unsigned int seconds)

seconds:经过了指定的seconds秒后会产生信号SIGALRM。

1、每个进程只能有一个闹钟时间。如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它还没有超时，以前登记的闹钟时间则被新值代换。

2、如果有以前登记的尚未超过的闹钟时间，而这次seconds值是0，则表示取消以前的闹钟。

 

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

# include <unistd.h>

int pause(void)

只有执行了一个信号处理函数后，挂起才结束。

信号的处理：

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

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

 

# include <signal.h>

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

 

typedef void(*sighandler_t) (int)

sighandler_t signal(int signum, sighandler_t handler)

 

Func可能的值是：

1、SIG_IGN：忽略此信号

2、SIG_DFL：按系统默认方式处理

3、信号处理函数名：使用该函数处理

下面是一个例子：mysignal.c

# 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(void)
{
printf("waiting for signal sigint or sigquit \n");

signal(SIGINT, my_func);
signal(SIGQUIT, my_func);

pause();
exit(0);
}

程序测试：

使用gcc生成可执行文件：gcc mysignal.c -o mysignal

运行可执行文件：./mysignal

程序进入等待状态

参看进程：ps -aux

regry    28963  0.0  0.5   4620  1480 pts/0    Ss   Oct30   0:00 -bash
regry    30651  0.0  0.1   1500   300 pts/0    S+   Oct30   0:00 ./mysignal
regry    31156  0.0  0.5   4492  1460 pts/1    Ss   00:06   0:00 -bash
regry    31200  0.0  0.3   4228   940 pts/1    R+   00:07   0:00 ps -aux
用kill函数发送信号：kill -s SIGINT 30651

运行结果显示：

[regry@campusnetwork test]$ ./mysignal
waiting for signal sigint or sigquit
i have get sigint

共享内存：

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

共享内存的实现分为两步：

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

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

 

int shmget（key_t key, int size, int shmflg）

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

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

 

映射：

int shmat(int shmid, char *shmaddr, int flag）用来允许本进程访问一块共享内存的函数。

参数：

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

shmaddr：如果 shmaddr 是NULL，系统将自动选择一个合适的地址！ 如果shmaddr不是NULL 并且没有指定SHM_RND 则此段连接到addr所指定的地址上 如果shmaddr非0 并且指定了SHM_RND 则此段连接到shmaddr -(shmaddr mod SHMLAB)所表示的地址上。SHM_RND命令的意思是取整,SHMLAB的意思是低边界地址的倍数，它总是2的乘方。该算式是将地址向下取最近一个 SHMLAB的倍数。 除非只计划在一种硬件上运行应用程序（这在当今是不大可能的），否则不用指定共享段所连接到的地址。所以一般应指定shmaddr为0，以便由内核选择地址。

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

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

 

当一个进程不再需要共享内存时，需要把它从进程地址空间中脱离。

int shmdt（char *shmaddr）

下面是一个例子：shmem.c

# 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);
}

return 0;
}

运行演示：

[regry@campusnetwork test]$ gcc -g shmem.c -o shmem
[regry@campusnetwork test]$ ls
mysignal  mysignal.c  pass  shmem  shmem.c
[regry@campusnetwork test]$ ./shmem ren
client get ren