Linux-进程通信

进程通讯

进程间通讯概述

目的

为什么进程间需要通信？

• 数据传输

  一个进程需要将它的数据发送给另一个进程

• 资源共享

  多个进程之间共享同样的资源

• 通知事件

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

• 进程控制

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

分类

Linux进程间通信包括：

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

• 信号（signal）

• 消息队列

• 共享内存

• 信号量

• 套接字（socket）

管道通信

什么是管道？

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

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

管道创建

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

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

int pipe(int filedis[2]);

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

管道关闭

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

管道读写

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

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

pipe_rw.c

#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

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

    int r_num;    

    char buf_r[100];

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

    if(pipe(pipe_fd) < 0)
    {
        printf("pipe create error
");
        return -1;
    }
    if((pid = fork()) == 0)
    {
        printf("
");
        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
", 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!
");
        if(write(pipe_fd[1], " Pipe", 5) != -1)
            printf("parent write2 Pipe!
");
        close(pipe_fd[1]);
        sleep(3);
        waitpid(pid, NULL, 0);
        exit(0);
    }
    return 0;
}

命名管道（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）

将对以后的读写产生如下影响：

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

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

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 <unistd.h>

#define FIFO "/tmp/myfifo"

int main(int argc, char **argv)
{
    int fd;
    char buf_r[100];
    int nread;

    if((mkfifo(FIFO, O_CREAT|O_EXCL) < 0) && (errno != EEXIST))
        printf("cannot create fifoserver
");

    printf("Preparing for reading bytes...
");
    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
");
        }
        printf("read %s from FIFO
", buf_r);
        sleep(1);
    }
    pause();
    unlink(FIFO);
}

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>
#include <unistd.h>

#define FIFO_SERVER "/tmp/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
");
        exit(-1);
    }

    strcpy(w_buf, argv[1]);

    if((nwrite = write(fd, w_buf, 100)) == -1)
    {
        if(errno == EAGAIN)
            printf("Yhe FIFO has not been read yet. Please try later
");
    }
    else
        printf("write %s to the FIFO
", w_buf);
}

信号通信

信号（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

   将信号发送给所有进程

Alarm

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

#include <unistd.h>
unsigned int alarm(unsigned int seconds)

seconds：经过了指定的seconds秒后产生信号SIGALRM

Pause

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

#include <unistd.h>
int pause(void)

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

信号的处理

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

signal

#include <signal.h>
void (*signal(int signo, void (*func)(int)))(int)

func可能的值是：

• SIG_IGN：忽略此信号

• SIG_DFL：按系统默认方式处理

• 信号处理函数名：使用该函数处理

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

void my_func(int sign_no)
{
    if(sign_no == SIGINT)
        printf("I have get SIGINT
");
    else if(sign_no == SIGQUIT)
        printf("I have get SIGQUIT
");
}
int main(void)
{
    printf("Waiting for signal SIGINT or SIGQUIT
"); 

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

    pause();
    exit(0);
}

kill -s SIGQUIT pid

共享内存

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

实现分为两个步骤：

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

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

创建

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

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

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

映射

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

参数：

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

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

返回值：如果成功，则返回共享内存映射到进程中的地址；如果失败，则返回-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
a", argv[0]);
        exit(1);
    }

    if((shmid = shmget(IPC_PRIVATE, 1024, PERM)) == -1)
    {
        fprintf(stderr, "Create Share memory Error:%s
a", strerror(errno));
        exit(1);
    }

    if(fork())
    {
        p_addr = shmat(shmid, 0, 0);//第二个参数0，表示系统帮助指定地址

        memset(p_addr, '', 1024);
        strncpy(p_addr, argv[1], 1024);
        wait(NULL);
        exit(0);
    }
    else
    {
        sleep(1);
        c_addr = shmat(shmid, 0, 0);
        printf("Client get %s
", c_addr);
        exit(0);
    }
}

消息队列

Unix早期通信机制之一的信号能够传送信息量有限，管道则只能传送无格式的字节流。消息队列（也叫做报文队列）则克服这些缺点。

消息队列就是一个消息的链表。可以把消息看做一个记录，具有特定的格式。进程可以向其中按照一定的规则添加新消息；另一些进程则可以从消息队列中读走消息。

分类

目前主要有两种类型的消息队列：POSIX消息队列以及系统V消息队列，系统V消息队列目前被大量使用

持续性

系统V消息队列是随内核持续的，只有在内核重启或者人工删除时，该消息队列才会被删除。

键值

消息队列的内核持续性要求每个消息队列都在系统范围内对应唯一的键值，所以，要获得一个消息队列的描述字，必须提供该消息队列的键值。

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(char *pathname, char proj)

功能：返回文件名对应的键值

pathname：文件名

proj：项目名（不为0即可）

打开/创建

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg)

key：键值，由ftok获得

msgflg：标志位

返回值：与键值key相对应的消息队列描述字。

常见的标志：

• IPC_CREAT 创建新的消息队列

• IPC_EXCL 与IPC_CREAT一同使用，表示如果要创建的消息队列已经存在，则返回错误。

• IPC_NOWAIT 读写消息队列要求无法满足时，不阻塞

创建

在以下两种情况下，将创建一个新的消息队列：

• 如果没有与键值key相对应的消息队列并且msgflg中包含了IPC_CREAT标志位。

• key参数为IPC_PRIVATE

int open_queue(key_t keyval)
{
    int qid;
    if((qid = magget(keyval, IPC_CREAT)) == -1){
        return (-1);
    }
    return (qid);
}

发送消息

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, struct msgbuf *msqp, int msgsz, int msgflg)

功能：向消息队列中发送一条消息

msgid：已打开的消息队列id

msgp：存放消息的结构

msgsz：消息数据长度

msgflg：发送标志，有意义的msgflg标志位IPC_NOWAIT，指明在消息队列没有足空间容纳要发送的消息时，magsnd是否等待。

消息格式

struct msgbuf{
    long mtype;//消息类型 > 0
    char mtext[1];//消息数据的首地址
}

接收消息

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgrcv(int msqid, struct msgbuf *msgp, int msgsz, long msgtyp, int msgflg)

功能：从msqid代表的消息队列中读取一个msgtyp类型的消息，并把消息存储在magp指向的msgbuf结构中。在成功读取了一条消息以后，队列中的这条消息将被删除。

例：

//接收消息
int read_message(int qid, long type, struct mymsgbuf* qbuf)
{
    int result, length;
    length = sizeof(struct mymsgbuf) - sizeof(long);
    if((result = msgrcv(qid, qbuf, length, type, 0)) == -1)
        return(-1);
    return (result);     
}

信号量

信号量与其他进程间通信方式不大相同，主要用途是保护临界资源。进程可以根据它判断是否能够访问某些资源。除了用于访问控制外，还可用于进程同步。

分类

二值信号量：信号量的值只能取0或1，类似于互斥锁。但两者有不同：信号量强调共享资源，只要共享资源可用，其他进程同样可以修改信号量的值；互斥所更强调进程，占用资源的进程使用完资源后，必须由进程本身来解锁。

计数信号量：信号量的值可以取任意非负值。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg)

key：键值，由ftok获得

nsems：指定打开或者新创建的信号量集中将包含信号量的数据

semflg：标识，同消息队列

操作

int semop(int semid, struct sembuf *sops, unsigned nsops)

功能：对信号量进行控制

semid：信号量集的ID

sops：是一个操作数组，表明要进行什么操作

nsops：sops所指向的数组的元素个数

struct sembuf{
    unsigned short sem_num; //semaphore index in array
    short sem_op; //semaphore operation
    short sem_flg;  //operation flags
};

sem_num：要操作的信号量在信号量集中的编号，第一个信号的编号是0。

sem_op：如果其值为正数，该值会加到现有的信号量值中，通常用于释放信号量；如果sem_op的值为负数，而其绝对值又大于信号的现值，操作将会阻塞，直到信号量大于或等于sem_op的绝对值，通常用于获取信号量；如果sem_op的值为0，则操作将暂时阻塞，直到信号的值变为0.

sem_flg：信号操作标志，可能的选择有两种：

• IPC_NOWAIT：对信号的操作不能满足时，semop()不会阻塞，并立即返回，同时设定错误信息。

• IPC_UNDO：程序结束时（不论正常或不正常）释放信号量，这样做的目的在于避免程序在异常情况下结束时未将锁定的资源解锁，造成该资源永远锁定。