apue学习笔记（第十五章 进程间通信）

本章将说明进程之间相互通信的其它技术----进程间通信（IPC）

管道

管道只能在具有公共祖先的两个进程之间只用。通常，一个管道由一个进程创建，在进程调用fork后，这个管道就能在父进程和子进程之间使用了。

管道是通过调用pipe函数创建的：

#include <unistd.h>
int pipe(int fd[2]);

经由参数fd返回两个文件描述符：fd[0]为读而打开，fd[1]为写而打开。fd[1]是输出，fd[0]是输入。

下图演示从父进程到子进程的管道（父进程关闭管道的读端(fd[0])，子进程关闭管道的写端(fd[1])）

下面程序创建了一个父进程到子进程的管道，并且父进程经由该管道向子进程传送数据

#include "apue.h"

int
main(void)
{
    int        n;
    int        fd[2];
    pid_t    pid;
    char    line[MAXLINE];

    if (pipe(fd) < 0)
        err_sys("pipe error");
    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {        /* parent */
        close(fd[0]);
        write(fd[1], "hello world
", 12);
    } else {                    /* child */
        close(fd[1]);
        n = read(fd[0], line, MAXLINE);
        write(STDOUT_FILENO, line, n);
    }
    exit(0);
}

函数popen和pclose

这两个函数实现的操作是：创建一个管道，fork一个子进程，关闭未使用的管道端，执行一个shell运行命令，然后等待命令终止。

#include <stdio.h>
FILE *popen(const char *cmdstring,const char *type);
int pclose(FILE *fp);

函数popen先执行fork，然后调用exec执行cmdstring，并且返回一个标准I/O文件指针。

如果type是“r”，则文件指针连接到cmdstring的标准输出

如果type是“w”，则文件指针连接到cmdstring的标准输入

pclose函数关闭标准I/O流，等待命令终止，然后返回shell的终止状态。

下面程序演示使用popen向分页程序传送文件

#include "apue.h"
#include <sys/wait.h>

#define    PAGER    "${PAGER:-more}" /* environment variable, or default */

int
main(int argc, char *argv[])
{
    char    line[MAXLINE];
    FILE    *fpin, *fpout;

    if (argc != 2)
        err_quit("usage: a.out <pathname>");
    if ((fpin = fopen(argv[1], "r")) == NULL)
        err_sys("can't open %s", argv[1]);

    if ((fpout = popen(PAGER, "w")) == NULL)
        err_sys("popen error");

    /* copy argv[1] to pager */
    while (fgets(line, MAXLINE, fpin) != NULL) {
        if (fputs(line, fpout) == EOF)
            err_sys("fputs error to pipe");
    }
    if (ferror(fpin))
        err_sys("fgets error");
    if (pclose(fpout) == -1)
        err_sys("pclose error");

    exit(0);
}

下面是程序运行的结果

考虑下面一个应用程序：它向标准输出写一个提示，然后从标准输入读一行，使用popen在应用程序和输入之间插入一个程序以便对输入进行变换

下面程序将演示这个过滤程序，它将输入的大写字符转换成小写字符

#include "apue.h"
#include <ctype.h>

int
main(void)
{
    int        c;

    while ((c = getchar()) != EOF) {
        if (isupper(c))
            c = tolower(c);
        if (putchar(c) == EOF)
            err_sys("output error");
        if (c == '
')
            fflush(stdout);
    }
    exit(0);
}

将这个过滤程序编译成可执行文件，然后下面程序用popen调用它

#include "apue.h"
#include <sys/wait.h>

int
main(void)
{
    char    line[MAXLINE];
    FILE    *fpin;

    if ((fpin = popen("myuclc", "r")) == NULL)
        err_sys("popen error");
    for ( ; ; ) {
        fputs("prompt> ", stdout);
        fflush(stdout);
        if (fgets(line, MAXLINE, fpin) == NULL)    /* read from pipe */
            break;
        if (fputs(line, stdout) == EOF)
            err_sys("fputs error to pipe");
    }
    if (pclose(fpin) == -1)
        err_sys("pclose error");
    putchar('
');
    exit(0);
}

协同进程

UNIX系统过滤程序从标准输入读取数据，向标准输出写数据。

当一个过滤程序既产生某个过滤程序的输入，又读取该过滤程序的输出时，它就变成了协同进程。

我们通过实例来观察协同进程。进程创建两个管道：一个是协同进程的标准输入，一个是协同进程的标准输出。

下面程序是一个简单的协同进程，它从其标准输入读取两个数，计算它们的和，然后将和写至其标准输出。

#include "apue.h"

int
main(void)
{
    int        n, int1, int2;
    char    line[MAXLINE];

    while ((n = read(STDIN_FILENO, line, MAXLINE)) > 0) {
        line[n] = 0;        /* null terminate */
        if (sscanf(line, "%d%d", &int1, &int2) == 2) {
            sprintf(line, "%d
", int1 + int2);
            n = strlen(line);
            if (write(STDOUT_FILENO, line, n) != n)
                err_sys("write error");
        } else {
            if (write(STDOUT_FILENO, "invalid args
", 13) != 13)
                err_sys("write error");
        }
    }
    exit(0);
}

对此程序进行编译，将其可执行文件目标代码存入名为add2的文件。

使用下面程序来调用add2协同进程，并将协同进程送来的值写到其标准输出。

#include "apue.h"

static void    sig_pipe(int);        /* our signal handler */

int
main(void)
{
    int        n, fd1[2], fd2[2];
    pid_t    pid;
    char    line[MAXLINE];

    if (signal(SIGPIPE, sig_pipe) == SIG_ERR)
        err_sys("signal error");

    if (pipe(fd1) < 0 || pipe(fd2) < 0)
        err_sys("pipe error");

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {                            /* parent */
        close(fd1[0]);
        close(fd2[1]);

        while (fgets(line, MAXLINE, stdin) != NULL) {
            n = strlen(line);
            if (write(fd1[1], line, n) != n)
                err_sys("write error to pipe");
            if ((n = read(fd2[0], line, MAXLINE)) < 0)
                err_sys("read error from pipe");
            if (n == 0) {
                err_msg("child closed pipe");
                break;
            }
            line[n] = 0;    /* null terminate */
            if (fputs(line, stdout) == EOF)
                err_sys("fputs error");
        }

        if (ferror(stdin))
            err_sys("fgets error on stdin");
        exit(0);
    } else {                                    /* child */
        close(fd1[1]);
        close(fd2[0]);
        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO)
                err_sys("dup2 error to stdin");
            close(fd1[0]);
        }

        if (fd2[1] != STDOUT_FILENO) {
            if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO)
                err_sys("dup2 error to stdout");
            close(fd2[1]);
        }
        if (execl("./add2", "add2", (char *)0) < 0)
            err_sys("execl error");
    }
    exit(0);
}

static void
sig_pipe(int signo)
{
    printf("SIGPIPE caught
");
    exit(1);
}

FIFO

FIFO有时被称为命名管道。与未命名管道不一样：通过FIFO，不相关的进程也能交换数据。

FIFO是一种文件类型，创建FIFO类似于创建文件

#include <sys/stat.h>
int mkfifo(const char *path,mode_t mode);
int mkfifoat(int fd,const char *path,mode_t mode);

考虑这样一个过程，它需要对一个经过过滤的输出流进行两次处理

使用FIFO和UNIX程序tee(1)就可以实现这样的过程而无需使用临时文件。

tee程序将其标准输入同时复制到其标准输出以及其命令行中命名的文件中。

mkfifo fifo1
prog3 < fifo1 &
prog1 < infile | tee fifo1 | prog2

创建FIFO，然后在后台启动prog3，从FIFO读数据。然后启动prog1，用tee将其输出发送到FIFO和prog2

FIFO的另一个用途是在客户进程和服务器进程之间传送数据。

如果有一个服务器进程，它与很多客户进程有关，每个客户进程都可将其请求写到一个该服务器进程创建的总所周知的FIFO中。

服务器可以使用下面的安排来响应客户进程（为每一个客户进程创建一个FIFO用来响应）

XSI IPC

有3中成果XSI IPC的IPC：消息队列、信号量以及共享存储器。

它们有如下相类似的特征：

1.标识符和键

2.权限结构

3.结构限制

消息队列

消息队列是消息的链接表，存储在内核中，由消息队列标识符标识。

信号量

信号量是一个计数器，用于为多个进程提供对共享数据对象的访问。

共享存储

共享存储允许两个或多个进程共享一个给定的存储区。