linux中的进程间通讯

房东的哈士奇

已于 2023-05-17 10:27:29 修改

阅读量94

点赞数

分类专栏： linux学习文章标签： linux 学习 ubuntu

于 2023-05-10 18:35:31 首次发布

本文链接：https://blog.csdn.net/weixin_70042862/article/details/130598060

版权

linux学习专栏收录该内容

17 篇文章 0 订阅

订阅专栏

通讯方式

单机通讯：FIFO，命名全双工通道，消息队列，信号，共享存储
联网通讯：STREAMS（嵌套字），socket

无名通道

只能用于父子进程或者兄弟进程中，有固定的写端和读端。生成的写端和读端的文件标识符不属于文件系统中，但能但文件的io进行操作，关通道，读通道，写通道都用标准c库中的文件操作函数执行。

创建函数：

int pipe(int fd[2]);

返回值：成功0 失败-1

fd[0]是读通道，fd[1]是写通道，若要关闭管道，将两个通道关闭即可。

运用实例：

先创建无名管道，然后创建子进程，子进程将sendbuf里的数据写入管道，父进程等待子进程结束，然后读管道中的数据。

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

int main(void)
{
        int pid,flag;
        int fd[2];
        char *sendBuf = "yzwddsg";
        char readBuf[1024] = {0};

        
        flag = pipe(fd);

        pid = fork();

        if(pid < 0)
        {
                printf("fork error\n");
        }
        else if(flag == -1)
        {
                printf("pipe error\n");
        }
        else if(pid > 0)
        {
                wait();
                printf("here is ppid\n");
                close(fd[1]);
                read(fd[0],readBuf,30);
                printf("get buff is:\n%s\n",readBuf);
        }
        else if(pid == 0)
        {

                close(fd[0]);
                printf("here id cpid\n");
                write(fd[1],sendBuf,30);
                printf("write succues\n");
                exit(0);
        }
                close(fd[0]);
                close(fd[1]);
}

我学习时找到的例程文件都是要在一个进程运行读或写时将另一个通道关闭，应该是怕双方同时进行同一个操作时会导致文件出错，我尝试不关闭另一个通道进行操作发现也能正常运行，甚至我运行完一个接一个收后，将功能翻转，发现数据传输是正常的，但莫名的是不知道为什么我printf输出的顺序被破坏了。

命名管道

以文件的形式存在磁盘中，无关进程间可以进行通讯，也是用标志c库下的文件操作函数进行操作

运用：

需要写两个函数，一个进行读管道，一个进行写管道

然后在读管道中运用mkfifo函数创建管道，如果创建成功返回0，失败返回-1（值得一提的是当管道文件已经操作的时候属于创建失败范畴），然后打开管道文件，读管道中的数据，如果管道中没数据那么将堵塞在读操作中，不再运行下去。

在写文件中直接进行打开管道文件，进行写操作。

读文件：

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

int main(void)
{
        char readBuf[1024] = {0};
        if(mkfifo("./file11",0600)==-1)
        {
                printf("fifo error\n");
        }
        printf("wait\n");
        sleep(3);
        int fd = open("./file11",O_RDONLY);
        read(fd,readBuf,30);
        printf("read succse,readBuf=%s\n",readBuf);
        close(fd);
}

写文件：

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

int main(void)
{
        char *sendBuf = "wtmznb";
        int fd = open("./file11",O_WRONLY);
        int nwrite = write(fd,sendBuf,30);
        printf("write succes,size = %d\n",nwrite);
        close(fd);
}

消息队列

消息队列独立用于读写文件之外，读写文件都关闭后消息队列仍然存在。

消息队列可以，获取特定消息，如发送时的信息类型为111，只有接收函数的该参数也为111才能接收到。

应用：

在读文件中创建消息队列，然后用msgrcv函数等待写入数据

在写文件中，定义一个数据结构体，然后将结构体写入发送队列函数msgsnd中，实现发送数据。

读文件

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

struct msgbuf
{
        long mtype;
        char mtext[128];
};

int main(void)
{
        key_t key;
        int msgId;
        struct msgbuf readbuf;

        key = ftok(".",1);

        if(key == -1)
        {
                printf("msg error\n");
                exit(-1);
        }

        msgId = msgget(key,IPC_CREAT|0777);

        msgrcv(msgId,&readbuf,sizeof(readbuf.mtext),888,0);

        printf("get buf is:%s\n",readbuf.mtext);

        msgctl(msgId,IPC_RMID,NULL);
}
~

写文件

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

struct msgbuf
{
        long mtype;
        char mtext[128];
};

int main(void)
{
        key_t key;
        int msgId;
        struct msgbuf sendbuf = {888,"yzwddsg"};

        key = ftok(".",1);

        if(key == -1)
        {
                printf("msg error\n");
                exit(-1);
        }

        msgId = msgget(key,IPC_CREAT|0777);

        msgsnd(msgId,&sendbuf,strlen(sendbuf.mtext),0);

        printf("get buf is:%s",sendbuf.mtext);

        msgctl(msgId,IPC_RMID,NULL);
}

共享内存

在物理内存中创建一个共享内存，文件的虚拟地址映射到同一个物理内存上，那么这块内存就是共享内存。

应用：

写函数开辟共享内存，读函数打开该共享内存，写函数将数据写入后等待5s，然后关闭共享内存，读函数在5s内读取共享内存。

写函数

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

int main(void)
{
        key_t key;
        char *shmaddr;

        int shmid;

        key = ftok(".",1);

        if(key == -1)
        {
                printf("msg error\n");
                exit(-1);
        }

        shmid = shmget(key,1024*2,IPC_CREAT|0666);

        shmaddr = shmat(shmid,0,0);
        strcpy(shmaddr,"slyyy");

        printf("shmid is:%d\n",shmid);
        sleep(8);


        shmdt(shmaddr);
        shmctl(shmid,IPC_RMID,NULL);
}

读函数

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

int main(void)
{
        key_t key;
        char *shmaddr;

        int shmid;

        key = ftok(".",1);

        if(key == -1)
        {
                printf("msg error\n");
                exit(-1);
        }

        shmid = shmget(key,1024*2,0);

        shmaddr = shmat(shmid,0,0);

        printf("shmid is:%d\n",shmid);
        printf("shmid is:%s\n",shmaddr);

        shmdt(shmaddr);

        return 0;

注意：如果写函数在读函数读取前就已经关闭共享内存了，那么读函数打开不了共享内存。

信号（初级用法）

信号定义在signal.h头中，具体信号名、信号id可以使用kill -l来查看，不存在0信号，kill对于信号0有特殊应用。

信号的处理方式有三种：忽略、捕捉、默认动作

应用：

信号接收处理函数：在mian中用signal捕获信号，然后到handler进行信号的处理，将接收到的信号id打印出来，并且打印对应的宏。

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

void handler(int signum)
{
        printf("signum = %d\n",signum);
        switch(signum)
        {
                case 2:
                        printf("signum = %d",signum);
                        break;
                case 9:
                        printf("signum = %d",signum);
                        break;
                case 10:
                        printf("signum = %d",signum);
                        break;
        }
}

int main(void)
{
        signal(SIGINT,handler);

        while(1);
        return 0;
}

信号发送函数，main设置为外部输入参数的模式，将argv[1]值将asc码转化为int型，写入sig。argv[2]值转化为int型写入pid，然后用kill函数发送信号。

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

int main(int argc,char **argv)
{
        int pid,sig;

        sig = atoi(argv[1]);
        pid = atoi(argv[2]);

        kill(pid,sig);

        return 0;
}

信号（高级）

在发送信号的同时可以携带数据，接收时也接收得到数据，进行相应处理。

应用：

数据接收函数：

将处理函数handler放入act结构体的函数指针中。

act结构体的sa_flag接收信号为SA_SIGINFO

然后用sigaction函数处理接收。

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

void handler(int signum,siginfo_t *info,void *context)
{
        printf("signum = %d\n",signum);
        if(context != NULL)
        {
                printf("get data = %d\n",info->si_int);
                printf("get data = %d\n",info->si_value.sival_int);
        }
}

int main(void)
{
        printf("pid = %d",getpid());
        sleep(3);

        struct sigaction act;
        act.sa_sigaction = handler;
        act.sa_flags = SA_SIGINFO;

        sigaction(SIGUSR1,&act,NULL);

        while(1);
        return 0;
}

发送数据：

大致与初级的信号处理代码一样，多了一个union sigval value的参数输入。然后在用sigqueue输出信号及value

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>

int main(int argc,char **argv)
{
        int pid,sig;

        sig = atoi(argv[1]);
        pid = atoi(argv[2]);

        union sigval value;
        value.sival_int = 100;

        sigqueue(pid,sig,value);

        return 0;
}