Linux下进程间通信

以下内容仅作为个人记录的参考，但也欢迎读者前来指正。

现在linux下使用较多的进程间通信方式主要有以下几种：
1.管道及有名管道（named pipe）。管道用于有亲缘关系进程间通信，有名管道没有亲缘关系限制。
2.信号（signal):信号是在软件层面对终端机制的一种模拟
3.消息队列（messagae queue）:克服前面的信息量有限的缺点，具有权限限制的功能
4.共享内存（shared memory）:多个进程可以同时访问同一块内存空间，依靠某种同步机制，如互斥锁和信号量。
5.信号量（semaphore）:主要作为进程之间以及同一进程的不同线程之间的同步和互斥手段
6.套接字（socket)

1.管道：

创建管道时，它会创建两个文件描述符fds[0]/fds[1]，分别固定为读/写。

#include<unistd.h>

int pipe(int fd[2]);

成功：返回0
失败：返回-1

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

int main()
{
        int pipefd[2];
        char buff[] = "hello";
        int len = strlen(buff);
        char* data;
        data = (char*)malloc(len+1);
        if(pipe(pipefd)<0)
        {
                printf("create pipe error.
");
                exit(1);
        }
        int pid;
        pid = fork();
        if(pid==0)
        {
                close(pipefd[1]);
                sleep(3);
                int readLen = read(pipefd[0],data,(len+1));
                if(readLen>0)
                {
                        printf("child recv %d bytes,and data is %s
",readLen,data);
                        exit(0);
                }

        }
        else if(pid>0)
        {
                close(pipefd[0]);
                sleep(1);
                int writeLen = write(pipefd[1],buff,len);
                printf("writeLen = %d
",writeLen);
                if(writeLen>0)
                {
                        printf("parent write %d bytes,and data is %s.
",writeLen,buff);
                        waitpid(pid,NULL,0);
                        exit(0);
                }
        }
        return 0;
}

标准流管道：

使用popen(const char* command,const char* type);
类似于shell执行command一样。
type可以是"r",该命令产生输出
"w",该命令产生输入

成功：返回文件流指针
失败：返回-1
pclose(fp)；关闭上面产生的文件流

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#define BUFSIZE 1024
int main()
{
        FILE* fp;
        char* cmd = "ps -ef";
        char buf[BUFSIZE];

        if((fp = popen(cmd,"r"))==NULL)
        {
                printf("popen error.
");
                exit(1);
        }

        while((fgets(buf,BUFSIZE,fp))!=NULL)
        {
                printf("%s",buf);
        }
        pclose(fp);
        exit(0);
}

 输出还不少啊。

FIFO：

有名管道：

使用mkfifo()函数，类似于open()

#include<sys/types.h>
#include<sys/state.h>

int mkfifo(const char* filename,mode_t mode);

mode:O_RDONLY/O_WRONLY/O_RDWR/O_NONBLOCK/O_CREAT/O_EXCL

成功返回0，失败返回-1

出错信息：
EACCESS/EEXIST/ENAMETOOLONG/ENOENT/ENOSPC/ENOTDIR/EROFS

fifo_read.c

#include<sys/types.h>
#include<sys/stat.h>
#include<errno.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<limits.h>

#define MYFIFO "/tmp/myfifo"
#define MAX_BUFFER_SIZE PIPE_BUF

int main()
{
        char buf[MAX_BUFFER_SIZE];
        int fd;
        int nread;

        if(access(MYFIFO,F_OK)==-1)
        {
                if((mkfifo(MYFIFO,0666)<0)&&(errno!=EEXIST))
                {
                        printf("cannot create fifo file
");
                        exit(1);
                }
        }

        fd = open(MYFIFO,O_RDONLY);
        if(fd==-1)
        {
                printf("open fifo file error");
                exit(1);
        }

        while(1)
        {
                memset(buf,0,sizeof(buf));
                if((nread = read(fd,buf,MAX_BUFFER_SIZE))>0)
                {
                        printf("read '%s' from fifo
",buf);
                }
        }
        close(fd);
        exit(0);
}

fifo_write.c

#include<sys/types.h>
#include<sys/stat.h>
#include<errno.h>
#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<limits.h>

#define MYFIFO "/tmp/myfifo"
#define MAX_BUFFER_SIZE PIPE_BUF

int main(int argc,char* argv[])
{
        int fd;
        char buf[MAX_BUFFER_SIZE];
        int nwrite;

        if(argc<=1)
        {
                printf("Usage: ./fifo_write string
");
                exit(1);
        }
        sscanf(argv[1],"%s",buf);

        fd = open(MYFIFO,O_WRONLY);
        if(fd==-1)
        {
                printf("open fifo file error
");
                exit(1);
        }
        if((nwrite=write(fd,buf,MAX_BUFFER_SIZE))>0)
        {
                printf("write '%s' to fifo
",buf);
        }
        close(fd);
        exit(0);
}

先启动读程序

 再启动写程序

信号与信号量暂且跳过，直接看一下共享内存。

共享内存：
分为两个步骤。
（1）：创建共享内存 shmget()，从内存获取一段共享内存区域
（2）：映射共享内存 把创建的共享内存映射到具体的进程空间，使用函数shmat()
撤销映射函数 shmdt()

shmget()

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int shmget(key_t key,int size,int shmflg);
key为共享内存的键值，特殊值IPC_PRIVATE，用于创建当前进程的私有共享内存
返回-1为出错，否则为共享内存标识符

shmat()

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

char* shmat(int shmid,const void* shmaddr,int shmflg);

shmflg:
SHM_RDONLY 只读，0为可读可写
-1：出错，否则返回被映射的段地址

shmdt()

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int shmdt(const void* shmaddr);
成功返回0，出错返回-1

shmem.c

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define BUFFER_SIZE 2048

int main()
{
        pid_t pid;
        int shmid;
        char* shm_addr;
        char flag[] = "write";
        char buff[BUFFER_SIZE];

        if((shmid = shmget(IPC_PRIVATE,BUFFER_SIZE,0666))<0)
        {
                perror("shmget");
                exit(1);
        }
        else
        {
                printf("create shared-memory: %d
",shmid);
        }
        system("ipcs -m");

        pid = fork();
        if(pid==-1)
        {
                perror("fork");
                exit(1);
        }
        else if(pid ==0)
        {
                if((shm_addr = shmat(shmid,0,0))==(void*)-1)
                {
                        perror("child: shmat");
                        exit(1);
                }
                else
                {
                        printf("child attach shared-memory: %p
",shm_addr);
                }
                system("ipcs -m");

                while(strncmp(shm_addr,flag,strlen(flag)))
                {
                        printf("child: wait enable data...
");
                        sleep(5);
                }

                strcpy(buff,shm_addr + strlen(flag));
                printf("child: shared-memory :%s
",buff);

                if(shmdt(shm_addr)<0)
                {
                        perror("shmdt");
                        exit(1);
                }
                else
                {
                        printf("child: deattach shared-memory
");
                }
                system("ipcs -m");

                if(shmctl(shmid,IPC_RMID,NULL)==-1)
                {
                        perror("child: shmctl(IPC_RMID)
");
                        exit(1);
                }
                else
                {
                        printf("delete shared-memory
");
                }
                system("ipcs -m");
        }
        else
        {
                if((shm_addr = shmat(shmid,0,0))==(void*)-1)
                {
                        perror("parent: shmat");
                        exit(1);
                }
                else
                {
                        printf("parent: attach shared-memory: %p
",shm_addr);
                }
                sleep(1);
                printf("
input some string:
");
                fgets(buff,BUFFER_SIZE,stdin);
                strncpy(shm_addr+strlen(flag),buff,strlen(buff));
                strncpy(shm_addr,flag,strlen(flag));

                if((shmdt(shm_addr))<0)
                {
                        perror("parent: shmdt");
                        exit(1);
                }
                else
                {
                        printf("parent: deattach shared-memory
");
                }
                system("ipcs -m");
                waitpid(pid,NULL,0);
                printf("finished
");
        }
}

运行结果：

[root@iZmcbceic4fsvzZ file]# gcc shmem.c 
[root@iZmcbceic4fsvzZ file]# ./a.out 
create shared-memory: 98307

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       666        2048       0                       
0x00000000 32769      root       666        2048       0                       
0x00000000 65538      root       666        2048       0                       
0x00000000 98307      root       666        2048       0                       

parent: attach shared-memory: 0x7f399d89e000
child attach shared-memory: 0x7f399d89e000

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       666        2048       0                       
0x00000000 32769      root       666        2048       0                       
0x00000000 65538      root       666        2048       0                       
0x00000000 98307      root       666        2048       2                       

child: wait enable data...

input some string:
hello world
parent: deattach shared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       666        2048       0                       
0x00000000 32769      root       666        2048       0                       
0x00000000 65538      root       666        2048       0                       
0x00000000 98307      root       666        2048       1                       

child: shared-memory :hello world

child: deattach shared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       666        2048       0                       
0x00000000 32769      root       666        2048       0                       
0x00000000 65538      root       666        2048       0                       
0x00000000 98307      root       666        2048       0                       

delete shared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          root       666        2048       0                       
0x00000000 32769      root       666        2048       0                       
0x00000000 65538      root       666        2048       0                       

finished
[root@iZmcbceic4fsvzZ file]# 

消息队列：

msgget()：创建和打开消息队列

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int msgget(key_t key,int msgflg);
key和共享内存类似，IPC_PRIVATE
出错返回-1，否则返回队列ID

msgsnd():发送消息

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int msgsnd(int msqid,const void* msgp,size_t msgsz,int msgflg)
msqid:消息队列的队列ID
msgp:指向消息结构的指针。
为一个结构体
struct msgbuf{
    long mtype;//消息类型
    char msgtext[1];//消息正文
};
msgsz:消息正文的字节数
msgflg:
IPC_NOWAIT 若消息无法立刻发送，直接返回
0：阻塞发送直到发送成功
出错返回-1，否则返回0

msgrcv():接收消息

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int msgrcv(int msgid,void* msgp,size_t msgsz,long int msgtype,int msgflg);
前3个参数，和msgsnd类似。
msgtype:
0:接收消息队列中第一个消息。
>0:接收消息队列中第一个为msgtype的消息
<0:接收消息中第一个类型值不小于msgtype绝对值，且类型值最小的消息。
msgflg:
MSG_ERROR:截断消息长度到不超过msgsz长度
IPC_NOWAIT:如果消息队列中没有响应类型消息可以接收，立即返回
0：阻塞接收，直到收到一条符合类型的消息
返回-1为出错，0为成功。

msgctl()：控制消息队列

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>

int msgctl(int msgid,int cmd,struct msqid_ds* buf);
cmd:
IPC_STAT，读取消息队列的数据结构，并储存再buf指定的地址。
IPC_SET，设置数据结构中的ipc_perm与
IPC_RMID:从系统内核中删除消息队列
出错返回-1，成功返回0

msgrcv.c

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#define BUFFER_SIZE 512

struct message{
        long msg_type;
        char msg_text[BUFFER_SIZE];
};

int main()
{
        int qid;
        key_t key;
        struct message msg;
        if((key = ftok(".",'a'))==-1)
        {
                perror("ftok");
                exit(1);
        }

        if((qid = msgget(key,IPC_CREAT|0666))==-1)
        {
                perror("msgget");
                exit(1);
        }
        printf("open queue %d
",qid);

        do{
                memset(msg.msg_text,0,BUFFER_SIZE);
                if(msgrcv(qid,(void*)&msg,BUFFER_SIZE,0,0)<0)
                {
                        perror("msgrcv");
                        exit(1);
                }
                printf("the message from process %d: %s
",msg.msg_type,msg.msg_text);
        } while(strncmp(msg.msg_text,"quit",4));

        if((msgctl(qid,IPC_RMID,NULL))<0)
        {
                perror("msgctl");
                exit(1);
        }
        exit(0);
}

msgsnd.c

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#define BUFFER_SIZE 512

struct message{
        long msg_type;
        char msg_text[BUFFER_SIZE];
};

int main()
{
        int qid;
        key_t key;
        struct message msg;
        if((key = ftok(".",'a'))==-1)
        {
                perror("ftok");
                exit(1);
        }

        if((qid = msgget(key,IPC_CREAT|0666))==-1)
        {
                perror("msgget");
                exit(1);
        }
        printf("open queue %d
",qid);

        while(1)
        {
                printf("enter some message to the queue:
");
                if((fgets(msg.msg_text,BUFFER_SIZE,stdin))==NULL)
                {
                        puts("no message");
                        exit(1);
                }
                msg.msg_type = getpid();
                if((msgsnd(qid,&msg,strlen(msg.msg_text),0))<0)
                {
                        perror("message posted.");
                        exit(1);
                }
                if(strncmp(msg.msg_text,"quit",4)==0)
                {
                        break;
                }
        }
        exit(0);
}