linux学习-系统编程之进程间通信

最新推荐文章于 2023-03-27 22:00:02 发布

onnnne

最新推荐文章于 2023-03-27 22:00:02 发布

阅读量205

点赞数

分类专栏：嵌入式

本文链接：https://blog.csdn.net/weixin_44263604/article/details/98957944

版权

嵌入式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

进程间通信简称IPC（interprocess communication），就是在不同进程之间消息传递的方式
主要的方式有管道、消息队列、共享内存、信号量等

1、管道

管道包括无名管道和命名管道，它们两个有什么特点呢？

无名管道：

具有固定的读写端、是一种单双工的通信模式
只能用于有亲缘关系的进程（父进程和子进程）
只存在内核当中

命名管道：

可以在无关的进程之间进行通信
以一种特殊的文件形式存在文件系统之间（FIFO是一种文件类型）它们之间的相同点：都可以阻塞读写，都用于scoket的网络通信

无名管道
在这里插入图片描述
管道创建成功会返回值为0，失败返回值为-1。
管道建立成功时，会生成固定的读写端：fd[0]为读端、fd[1]为写端，同样可以利用read函数和write函数对管道进行读写，需要关闭管道时，只需要用close函数将fd[0]和fd[1]关闭就可以了。

如果我们想要实现从父进程发送消息到子进程，则关闭父进程的fd[0]读端和子进程的fd[1]写端，反之，子进程向父进程发送消息，则需要关闭父进程的fd[1]写端和子进程的fd[0]读端。
如果不好记忆，可以这样记：父进程要向子进程发送消息，所需要写东西给子进程，所以就需要关闭读端，子进程跟父进程相反，反之也是一样的。

代码实现：

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

int main() {
    int fd[2];
    int pid;
    char buf[128];
    if (pipe(fd) == -1) {  //判断管道是否创建成功

        printf("creat pipe failed\n");
    }

    pid = fork();//创建子进程
    if (pid < 0) {
        printf("creat child failed\n");

    } else if (pid > 0) {
        sleep(3);
        printf("this is father\n");
        close(fd[0]);//关闭读端
        write(fd[1], "hello", strlen("hello"));//将hello发送给子进程
        wait();

    } else {
        printf("this is child\n");
        close(fd[1]);//关闭写端
        read(fd[0], buf, 128);//接收从父进程发来的消息
        printf("read from father:%s\n", buf);
        exit(0);
    }

    return 0;
}

再实现一个例子：实现文件拷贝，要求使用父子进程加管道的方式做
具体需求：
父进程负责读取指定文件，将读取内容通过管道发送给子进程，子进程通过管道读取到父进程发来的消息，并创建文件，保存内容

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

int main(int argc, char **argv) {
    int fd1;
    int fd2;
    int fd[2];
    int pid;
    int n_write;
    int n_read;
    char buf[128];
    if (pipe(fd) == -1) {

        printf("creat pipe failed\n");
    }

    pid = fork();
    if (pid < 0) {
        printf("creat child failed\n");

    } else if (pid > 0) {
        sleep(3);
        printf("this is father\n");
        fd1 = open(argv[1], O_RDWR);//父进程打开文件1
        if (fd1 == -1) {
            perror("open file fail");
            exit(0);
        }
        memset(buf, '\0', strlen(buf));//对字符串内容清空
        n_read = read(fd1, buf, 128);//对文件1内容进行读
        if (n_read > 0) {
            printf("get %s context successfully\n", argv[1]);
        }
        close(fd1);//关闭文件1
        close(fd[0]);//关闭父进程的读端
        write(fd[1], buf, strlen(buf));//通过管道向子进程发送所读取的内容
        wait();
        n_read = 0;

    } else {
        printf("this is child\n");
        close(fd[1]);//关闭子进程的写端
        memset(buf, '\0', 128);//清空字符串内容
        n_read = read(fd[0], buf, 128);//读取从父进程发送过来的内容
        if (n_read > 0) {
            printf(
                "read from father successfully\n this context copy is "
                "beginning\n");
        }
        fd2 = open(argv[2], O_CREAT | O_RDWR, 0600);//创建文件2
        if (fd2 == -1) {
            printf("creat file2 failed");
        }
       n_write= write(fd2, buf, strlen(buf));//将读取的内容写入文件2
       if(n_write>0){
            printf("copy to %s  successfully\n",argv[2]);

       }
        //  printf("read from father:%s\n", buf);
        close(fd2);//关闭文件2
        exit(0);
    }

    return 0;
}

FIFO（命名管道）

函数原型：int mkfifo(const char *pathname,mode_t mode)
mode参数：跟open的mode参数相同
pathname：文件名（含路径）
返回值：成功：0，失败：-1
代码实现创建：

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
int main(){
    int ret=mkfifo("./file",0600);
    if(ret==0){
        printf("mkfifo sucessfully\n");

    }
    if(ret==-1){

        printf("mkfifo failed\n");

    }
    return 0;
}

例子：利用FIFO实现文件之间的数据传输
read.c

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

int main(){
    char buf[30]={0};
    int n_read=0;
    if((mkfifo("./file",0600)==-1)&&errno!=EEXIST){ //创建FIFO
        printf("mkfifo failed\n");
        perror("why");
    }
    int fd=open("./file",O_RDONLY); //只读方式打开
    printf("open sucessfully\n");
    while(1){
     n_read=read(fd,buf,30);
     printf("read from %d byte from fifo,context:%s\n",n_read,buf);
     sleep(1);
    }
    return 0;
}

write.c

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

int main() {
    int cnt;
    char *buf = "message from fife";
    int fd = open("./file", O_WRONLY); //只写方式打开
    printf("WRITE open sucessfully\n");
    while(1){  //不断写入，写入3次后不再写入
    write(fd, buf, strlen(buf)); 
    sleep(1);
    if(cnt==3) break;
    cnt++;
    }
    close(fd);
    return 0;
}

运行结果：
在这里插入图片描述

共享内存

什么是共享内存？–简单地说就是允许不同的进程访问同一个内存，
共享内存适用于一个程序的多进程通信，通常也跟信号量一起使用
使用共享内存有以下步骤：

创建共享内存/打开共享内存
映射
数据交换
释放共享内存
删除共享内存

头文件:#include <sys/shm.h>
主要的函数：

int shmget(key_t key,size_t size,int flag);//创建或者打开一个共享内存

返回值：成功：共享内存ID，失败：-1

void *shmat(int shm_id,const void *addr,int flag);//连接共享内存到当前进程

返回值：成功：共享内存ID，失败：-1

int shmdt(void *addr);//断开共享内存

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

int shmctl(int shm_id,int cmd,struct shmid_de *buf);//控制共享内存的相关信息

返回值：成功：0，失败：-1
参数 cmd ：执行相应的操作。常用的是IPC_RMID（从系统中删除该共享内存）

代码实现：

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(){
    int shmid;
    char *shmaddr;
    key_t key;
    key=ftok(".",1);//建立IPC通讯，获取id值

    shmid=shmget(key,1024*4,IPC_CREAT|0666);//创建共享内存/获取共享内存
    if(shmid== -1){
        printf("shmget nook\n");
        exit(-1);

    }
    
    shmaddr=shmat(shmid,0,0); //连接共享内存
    printf("shmat ok\n");

    strcpy(shmaddr,"kkkk");
    sleep(5);
    shmdt(shmaddr);// 断开共享内存

    shmctl(shmid,IPC_RMID,0);//删除共享内存
    printf("quit\n");


    return 0;
}

在这里插入图片描述
主要功能：系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。
参数说明：
pathname：指定的文档名
id：子序号，可以随意设定，unix系统的取值是1到255

信号量

信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。

1、特点

信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。

信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。

每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。

支持信号量组。

2、原型

最简单的信号量是只能取 0 和 1 的变量，这也是信号量最常见的一种形式，叫做二值信号量（Binary Semaphore）。而可以取多个正整数的信号量被称为通用信号量。

Linux 下的信号量函数都是在通用的信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。

#include <sys/sem.h>
 // 创建或获取一个信号量组：若成功返回信号量集ID，失败返回-1
 int semget(key_t key, int num_sems, int sem_flags);
 // 对信号量组进行操作，改变信号量的值：成功返回0，失败返回-1
 int semop(int semid, struct sembuf semoparray[], size_t numops);  
 // 控制信号量的相关信息
 int semctl(int semid, int sem_num, int cmd, ...);

当semget创建新的信号量集合时，必须指定集合中信号量的个数（即num_sems），通常为1；如果是引用一个现有的集合，则将num_sems指定为 0 。

在semop函数中，sembuf结构的定义如下：

1 struct sembuf
2 {
3 short sem_num; // 信号量组中对应的序号，0～sem_nums-1
4 short sem_op; // 信号量值在一次操作中的改变量
5 short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }

其中 sem_op 是一次操作中的信号量的改变量：

若sem_op > 0，表示进程释放相应的资源数，将 sem_op 的值加到信号量的值上。如果有进程正在休眠等待此信号量，则换行它们。

若sem_op < 0，请求 sem_op 的绝对值的资源。

sem_flg通常为IPC_NOWAIT 或 SEM_UNDO.
sem_flg 指定IPC_NOWAIT，则semop函数出错返回EAGAIN。
sem_flg 没有指定IPC_NOWAIT，则将该信号量的semncnt值加1，然后进程挂起直到下述情况发生：

此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，此情况下将此信号量的semncnt值减1，函数semop出错返回EINTR
若sem_op == 0，进程阻塞直到信号量的相应值为0：

当信号量已经为0，函数立即返回。

信号量值为0，将信号量的semzcnt的值减1，函数semop成功返回；此信号量被删除，函数smeop出错返回EIDRM；
进程捕捉到信号，并从信号处理函数返回，在此情况将此信号量的semncnt值减1，函数semop出错返回EINTR

在semctl函数中的命令有多种，这里就说两个常用的：

**SETVAL：**用于初始化信号量为一个已知的值。所需要的值作为联合semun的val成员来传递。在信号量第一次使用之前需要设置信号量。
**IPC_RMID：**删除一个信号量集合。如果不删除信号量，它将继续在系统中存在，即使程序已经退出，它可能在你下次运行此程序时引发问题，而且信号量是一种有限的资源。

转载：本文为CSDN博主「南宫凌霄」的原创文章。
原文链接：https://blog.csdn.net/wh_sjc/article/details/70283843

代码实现：信号量和共享内存的使用

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

union semun {
        int val;
        struct semid_ds *buf;
        unsigned short *array;
        struct seminfo *_buf;
};

void getkey(int id){
    struct sembuf set;
    set.sem_num=0;
    set.sem_op=-1; //请求资源
    set.sem_flg=SEM_UNDO;
    semop(id,&set,1);
    printf("getkey\n");

}

void putkey(int id){
    struct sembuf set;
    set.sem_num=0;
    set.sem_op=1;//释放资源
    set.sem_flg=SEM_UNDO;
    semop(id,&set,1);
    printf("putkey\n");
}
int main(int argc,char **argv){

    key_t key;
    int semid;
    key=ftok(".",2);

    semid=semget(key,1,IPC_CREAT|0666);//创建信号量组
    
    union semun initsem;
    initsem.val=0;

    semctl(semid,0,SETVAL,initsem); //控制信号量组
    
    int pid=fork();//创建进程

    if(pid>0){
        getkey(semid);//获取钥匙
        printf("this is father\n");
        putkey(semid);//释放钥匙
        semctl(semid,0,IPC_RMID);
    }else if(pid==0){
        printf("this is child\n");
        putkey(semid);//释放钥匙

    }else{
        printf("fork error\n");


    }


    return 0;
}

onnnne

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
linux学习-系统编程之进程间通信

进程间通信简称IPC（interprocess communication），就是在不同进程之间消息传递的方式主要的方式有管道、消息队列、共享内存、信号量等1、管道管道包括无名管道和命名管道，它们两个有什么特点呢？无名管道：具有固定的读写端、是一种单双工的通信模式只能用于有亲缘关系的进程（父进程和子进程）只存在内核当中命名管道：可以在无关的进程之间进行通信以一种特殊...
复制链接

扫一扫