Linux进程间通信（一）——管道、信号量 .

最新推荐文章于 2023-03-13 22:41:04 发布
最新推荐文章于 2023-03-13 22:41:04 发布
阅读量649 收藏
点赞数
分类专栏： ARM/linux
一、Linux进程间通信方式 ：有六种方式在两个程序间传递信息

 

        1、信号( Singal )

        2、管道 ( Pipe ) 及有名管道

        3、信号量 ( Semaphore )

        4、共享内存 ( SharedMessage)

        5、消息队列 ( MessageQueue )

        6、套接字  ( Socket )

 

     其中，共享内存是效率最高的。

 

二、具体介绍

 

        1、信号( Singal )   可以参考 linux多进程——进程组与会话、守护进程、信号通信  中的信号通信部分

 

        2、管道 ( Pipe ) 及有名管道

  

                管道分为有名和无名管道。

 

              无名管道用于父子进程间的通信。

 

      a、用pipe( )创建无名管道       

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<sys/types.h>   
  4. #include<memory.h>   
  5. #include<signal.h>   
  6.   
  7. void my_func(int);  
  8.   
  9. int main(){  
  10.     pid_t pid;  
  11.     int pfd[2];  
  12.     char *msg="pipe test program";  
  13.     char buf[100];  
  14.     int r,w;  
  15.     memset(buf,0,sizeof(buf));  
  16.     //创建一个无名管道。一定要在fork之前创建。这样子进程才能有同样的一个管道   
  17.     if(pipe(pfd)<0){  
  18.         printf("pipe create error!\n");  
  19.         exit(1);  
  20.     }  
  21.   
  22.     if((pid = fork())<0){  
  23.         printf("fork error!\n");  
  24.         exit(1);  
  25.     }else if(pid == 0){  
  26.         //close(pfd[0]);   //此句是测试异常的时候使用   
  27.         close(pfd[1]);  
  28.         sleep(3);  
  29.         if(r=read(pfd[0],buf,100)<0){  
  30.             printf("read error!\n");  
  31.             waitpid(pid,NULL,0);     //等待子进程退出后再退出   
  32.             exit(1);  
  33.         }else  
  34.             printf("child read from pipe: %s\n",buf);  
  35.         close(pfd[0]);  
  36.     }else{  
  37.         signal(SIGPIPE,my_func);    //当读端不存在时系统发出SIGPIPE信号   
  38.         close(pfd[0]);  
  39.         sleep(1);  
  40.         if(w=write(pfd[1],msg,strlen(msg))<0){  
  41.             printf("wirte error!\n");  
  42.             exit(1);  
  43.         }else  
  44.             printf("parent send msg to child!\n");  
  45.         close(pfd[1]);  
  46.         waitpid(pid,NULL,0);  
  47.     }  
  48.     return 0;  
  49. }  
  50.   
  51. void my_func(int sig){  
  52.     if(sig == SIGPIPE){  
  53.         printf("read not exist\n");  
  54.     }  
  55. }  
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<memory.h>
#include<signal.h>

void my_func(int);

int main(){
    pid_t pid;
    int pfd[2];
    char *msg="pipe test program";
    char buf[100];
    int r,w;
    memset(buf,0,sizeof(buf));
    //创建一个无名管道。一定要在fork之前创建。这样子进程才能有同样的一个管道
    if(pipe(pfd)<0){
        printf("pipe create error!\n");
        exit(1);
    }

    if((pid = fork())<0){
        printf("fork error!\n");
        exit(1);
    }else if(pid == 0){
        //close(pfd[0]);   //此句是测试异常的时候使用
        close(pfd[1]);
        sleep(3);
        if(r=read(pfd[0],buf,100)<0){
            printf("read error!\n");
            waitpid(pid,NULL,0);     //等待子进程退出后再退出
            exit(1);
        }else
            printf("child read from pipe: %s\n",buf);
        close(pfd[0]);
    }else{
        signal(SIGPIPE,my_func);    //当读端不存在时系统发出SIGPIPE信号
        close(pfd[0]);
        sleep(1);
        if(w=write(pfd[1],msg,strlen(msg))<0){
            printf("wirte error!\n");
            exit(1);
        }else
            printf("parent send msg to child!\n");
        close(pfd[1]);
        waitpid(pid,NULL,0);
    }
    return 0;
}

void my_func(int sig){
    if(sig == SIGPIPE){
        printf("read not exist\n");
    }
}

 

    b、标准流管道： popen() 

 

         这个函数会完成：创建管道、fork()、关闭相应的文件描述符、执行exec、执行函数中指定的命令    这一系列的操作。优点当然是省事啦，缺点必然是不灵活。popen( )返回的是文件指针所以要用标准IO操作。其中，第二个参数：" r " 表示命令的输出作为程序的输入；" w " 表示程序的输出作为命令的输入。另外要注意用pclose( ) 关闭文件流。两个函数出错

   

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<sys/types.h>   
  4. #include<memory.h>   
  5. #include<signal.h>   
  6.   
  7. int main(){  
  8.     FILE *fp;  
  9.     int pfd[2];  
  10.     char *cmd="ls -l";  
  11.     char buf[100];  
  12.     if((fp=popen(cmd,"r")) == NULL){  
  13.         printf("popen error\n");  
  14.         exit(1);  
  15.     }  
  16.     while(fgets(buf,100,fp)!= NULL){  
  17.         printf("from fp:%s",buf);  
  18.     }  
  19.     pclose(fp);  
  20.     return 0;  
  21. }  
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<memory.h>
#include<signal.h>

int main(){
    FILE *fp;
    int pfd[2];
    char *cmd="ls -l";
    char buf[100];
    if((fp=popen(cmd,"r")) == NULL){
        printf("popen error\n");
        exit(1);
    }
    while(fgets(buf,100,fp)!= NULL){
        printf("from fp:%s",buf);
    }
    pclose(fp);
    return 0;
}

 

     c、有名管道FIFO

   

       读数据的程序：

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<fcntl.h>   
  3. #include<unistd.h>   
  4. #include<memory.h>   
  5. #include<errno.h>   
  6. #include<stdlib.h>   
  7.   
  8. #define FIFO "pipetest"   
  9. int main(int argc,char* argv[]){  
  10.     int fd,r;  
  11.     char buff[1024];  
  12.     if(access(FIFO,F_OK)==-1){       //判断管道是否存在，管道是不可以重复创建的   
  13.         if(mkfifo(FIFO,0666)<0){  
  14.             if(errno==EEXIST)  
  15.             printf("it already exist\n");  
  16.             printf("create fifo error! it already exist\n");  
  17.             exit(1);  
  18.         }  
  19.     }  
  20.     if((fd=open("in1",O_RDONLY))<0){  
  21.         printf("open in1 error!\n");  
  22.         return 1;  
  23.     }  
  24.     while(1){  
  25.         memset(buff,0,1024);  
  26.         if(r=read(fd,buff,1024)>0){  
  27.             printf("send to name pipe: %s\n",buff);  
  28.         }  
  29.     }  
  30.     close(fd);  
  31. }  
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<memory.h>
#include<errno.h>
#include<stdlib.h>

#define FIFO "pipetest"
int main(int argc,char* argv[]){
    int fd,r;
    char buff[1024];
    if(access(FIFO,F_OK)==-1){       //判断管道是否存在，管道是不可以重复创建的
        if(mkfifo(FIFO,0666)<0){
            if(errno==EEXIST)
            printf("it already exist\n");
            printf("create fifo error! it already exist\n");
            exit(1);
        }
    }
    if((fd=open("in1",O_RDONLY))<0){
        printf("open in1 error!\n");
        return 1;
    }
    while(1){
        memset(buff,0,1024);
        if(r=read(fd,buff,1024)>0){
            printf("send to name pipe: %s\n",buff);
        }
    }
    close(fd);
}

        

       写数据的程序：

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<fcntl.h>   
  3. #include<unistd.h>   
  4. #include<memory.h>   
  5. #include<errno.h>   
  6. #include<stdlib.h>   
  7.   
  8. #define FIFO "pipetest"   
  9. int main(int argc,char* argv[]){  
  10.     int fd,w;  
  11.     char buff[1024];  
  12.     if(argc<2){  
  13.         printf("Usage: ./%s <string>\n",argv[0]);  
  14.         exit(0);  
  15.     }  
  16.     sscanf(argv[1],"%s",buff);  
  17.     if(access(FIFO,F_OK)==-1){  
  18.         if(mkfifo(FIFO,0666)<0){  
  19.             if(errno==EEXIST)  
  20.             printf("it already exist\n");  
  21.             printf("create fifo error!\n");  
  22.             exit(1);  
  23.         }  
  24.     }  
  25.     if((fd=open("in1",O_WRONLY))<0){  
  26.         printf("open in1 error!\n");  
  27.         return 1;  
  28.     }  
  29.     if(w=write(fd,buff,1024)>0){  
  30.         printf("send to name pipe: %s\n",buff);  
  31.     }  
  32.     close(fd);  
  33. }  
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<memory.h>
#include<errno.h>
#include<stdlib.h>

#define FIFO "pipetest"
int main(int argc,char* argv[]){
    int fd,w;
    char buff[1024];
    if(argc<2){
        printf("Usage: ./%s <string>\n",argv[0]);
        exit(0);
    }
    sscanf(argv[1],"%s",buff);
    if(access(FIFO,F_OK)==-1){
        if(mkfifo(FIFO,0666)<0){
            if(errno==EEXIST)
            printf("it already exist\n");
            printf("create fifo error!\n");
            exit(1);
        }
    }
    if((fd=open("in1",O_WRONLY))<0){
        printf("open in1 error!\n");
        return 1;
    }
    if(w=write(fd,buff,1024)>0){
        printf("send to name pipe: %s\n",buff);
    }
    close(fd);
}

 

            3、信号量

           信号量和信号通信( Signal )可不一样。信号量( Semaphore ) 是用于解决不同程序间的访问问题。即同步和互斥。

 

           同步是指多线程程序按照一定的顺序执行一段完整的代码。互斥指多线程程序访问同一个变量时只能有一个线程在访问。

 

                 信号量就是为了解决同步和互斥的IPC机制，信号量为0则没有资源，进程进入等待队列，直到资源被释放为止。

 

            信号量编程的步骤：

                1、创建信号量或获得在系统中已经存在的信号量

                          调用semget () 函数 。使用同一个信号量键值即可获得同一个信号量。

                 2、初始化信号量

                          使用semctl( ) 函数的SETVAL。当使用二维信号量时，初始化为1。

                 3、进行信号量的PV操作

                          调用semop( ) 。实现同步与互斥。

                 4、不需要信号量则从系统中删除

                          使用semclt( ) 函数的IPC_RMID 。

 

           一个操作方法的封装函数文件：     

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<fcntl.h>   
  3. #include<unistd.h>   
  4. #include<memory.h>   
  5. #include<errno.h>   
  6. #include<stdlib.h>   
  7.   
  8. #define FIFO "pipetest"   
  9. int main(int argc,char* argv[]){  
  10.     int fd,w;  
  11.     char buff[1024];  
  12.     if(argc<2){  
  13.         printf("Usage: ./%s <string>\n",argv[0]);  
  14.         exit(0);  
  15.     }  
  16.     sscanf(argv[1],"%s",buff);  
  17.     if(access(FIFO,F_OK)==-1){  
  18.         if(mkfifo(FIFO,0666)<0){  
  19.             if(errno==EEXIST)  
  20.             printf("it already exist\n");  
  21.             printf("create fifo error! it already exist\n");  
  22.             exit(1);  
  23.         }  
  24.     }  
  25.     if((fd=open("in1",O_WRONLY))<0){  
  26.         printf("open in1 error!\n");  
  27.         return 1;  
  28.     }  
  29.     if(w=write(fd,buff,1024)>0){  
  30.         printf("send to name pipe: %s\n",buff);  
  31.     }  
  32.     close(fd);  
  33. }  
#include<stdio.h>
#include<fcntl.h>
#include<unistd.h>
#include<memory.h>
#include<errno.h>
#include<stdlib.h>

#define FIFO "pipetest"
int main(int argc,char* argv[]){
    int fd,w;
    char buff[1024];
    if(argc<2){
        printf("Usage: ./%s <string>\n",argv[0]);
        exit(0);
    }
    sscanf(argv[1],"%s",buff);
    if(access(FIFO,F_OK)==-1){
        if(mkfifo(FIFO,0666)<0){
            if(errno==EEXIST)
            printf("it already exist\n");
            printf("create fifo error! it already exist\n");
            exit(1);
        }
    }
    if((fd=open("in1",O_WRONLY))<0){
        printf("open in1 error!\n");
        return 1;
    }
    if(w=write(fd,buff,1024)>0){
        printf("send to name pipe: %s\n",buff);
    }
    close(fd);
}

 

                 调用的例子：

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<sys/types.h>   
  4. #include<sys/ipc.h>   
  5. #include<sys/sem.h>   
  6. #include"semcom.c"   
  7.   
  8. int main(){  
  9.     pid_t pid;  
  10.     int semid;  
  11.     if((semid=semget(ftok(".",'a'),1,0666|IPC_CREAT))<0){   //创建信号量   
  12.         printf("semget error!\n");  
  13.         exit(1);  
  14.     }  
  15.     init_sem(semid,1);  
  16.     if((pid = fork())<0){  
  17.         printf("fork error!\n");  
  18.         exit(1);  
  19.     }else if(pid == 0){  
  20.         sem_p(semid);           //在未释放之前父进程无法访问   
  21.         printf("child is running......\n");  
  22.         sleep(3);  
  23.         printf("son is %d  wake\n",getpid());  
  24.         sem_v(semid);  
  25.     }else{  
  26.         sem_p(semid);  
  27.         printf("parent is running......\n");  
  28.         sleep(3);  
  29.         printf("parent is %d  wake\n",getpid());  
  30.         sem_v(semid);  
  31.         sleep(6);  
  32.         del_sem(semid);  
  33.     }  
  34.     return 0;  
  35. }  
任财
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程间通信——使用信号量
haierboos
08-24 4330
这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——使用信号。下面就进入信号量的讲解。 一、什么是信号量 为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临...
Linux——进程间通信（信号量）
qq_44824574的博客
11-18 1416
临界资源： 同一时刻只能一个进程（线程）访问的资源——>一块物理内存（共享内存），显示终端，打印机。 临界区： 程序中访问临界资源的代码区域。 原子操作： 不能被中断的操作。 i++不是原子操作，三步操作 P，V操作 都是原子操作 P操作-1操作，临界区之前 V操作+1操作，临界区之后 信号量： 是一个特殊的计数器，来完成多进程环境下进程执行的同步控制。 信号量是一个值，当信号量大于0时，记录的是临界资源的个数，此时对信号量执行P操作不会组设，当信号量的值为0时，执行p操作会被阻塞，直到另一个进程对该
Linux进程间通信：信号量
最新发布
m0_69190774的博客
03-13 377
1.1 共享资源访问的流程 1. 2信号量函数 1.2.4PV操作流程 对于sem_op取值有三种情况： 1.sem_op 为负值：这表示进程希望获取临界资源的使用权。 若当前可占用的资源数大于sem_op的绝对值，则用信号量值减去sem_op的绝对值，表示已被进程访问使用； 若当前可占用的资源数小于sem_op的绝对值，则有两种结果：标志位设为IPC_NOWAIT，则程序出错，返回一个error：EAGAIN；未设为IPC_NOWAIT，则程序进入休眠状态直到以下任一条件满足：（1）可占用资源数大于s
Linux进程间通信②：有名管道FIFO
一只老风铃
10-11 335
常规的匿名管道通过pipe创建一片内存缓冲区，并对外提供两个文件描述符，用于只读或者只写操作。但其使用范围很小，只能用于父、子进程间的通信。因此Linux还提供有名管道的支持。 管道的本质是一片可以读写的缓冲区域，Linux将其描述为文件（UNIX思想：一切IO皆是文件） 对于有名管道，其主要特点是： 存在于文件系统中，包含文件名，管道文件被组织成树状结构 两个进程之间无需有联系，可以通过管道进行通信 对有名管道的操作和文件操作类似，支持读，写 【有名管道的创建】 mkfifo(const.
Linux进程间通信——管道 & FIFO
0 error(s)
09-02 491
管道 管道时一种最基本的IPC机制，作用于有血缘关系的进程使用。 它由pipe函数创建，提供一个单向数据流
Linux进程间通信-信号通信实例.pdf
07-11
信号是Linux系统中用于进程间通信的一种轻量级机制，它允许一个进程向另一个进程发送一个消息，告知接收进程发生了某种事件或需要执行某个动作。信号通信具有快速、简单的特点，但同时也存在信息量有限和同步能力较...
Linux进程间通信-信号通信信号发送实例.pdf
07-11
总结来说，信号通信是Linux IPC的重要组成部分，它提供了简单而快速的进程间通信方式。通过`kill`、`raise`和`sigqueue`等函数，程序员可以灵活地控制和传递信息，实现进程间的交互。然而，由于信号携带信息有限，...
高级进程间通信问题——快速排序问题1
08-03
【高级进程间通信问题——快速排序问题1】的实验是一个基于操作系统原理的编程挑战，旨在实现一个多线程或多进程的快速排序算法。这个实验在Ubuntu 18.04.5 LTS环境下进行，采用C/C++编程语言，并且允许使用C++11的...
Linux进程间通信（一）——Sam用图概述
08-03
总结，Linux进程间通信是多任务环境下实现进程协作的关键，通过管道、信号量、消息队列、共享内存和套接字等多种手段，开发者可以构建出复杂而灵活的系统。结合Sam的图解学习，可以更好地理解和应用这些技术。
LINUX进程间通信的模型检测.pdf
09-06
文章首先分析了Linux进程间通信的部分源代码，这部分代码可能包括信号、管道、消息队列、共享内存、套接字等常见的IPC机制。通过手工形式化建模，作者将这些复杂的交互行为转化为有限状态自动机，这是一种能够描述...
Linux进程间通信（九）——信号量
天山老妖
02-28 2649
一、信号量简介 信号量是解决进程之间的同步与互斥的IPC机制，互斥与同步关系存在的根源在于临界资源。临界资源是在同一个时刻只允许有限个（通常只有一个）进程可以访问（读）或修改（写）的资源，临界资源包括：硬件资源（处理器、内存、存储器以及其他外围设备等）和软件资源（共享代码段、共享结构和变量等）。 信号量是描述某一种资源是否可用的变量，信号量的值表示当前可用的资源的数量，若信号量的值等于0则意味着目前没有可用的资源。 对信号量进行的两个原子操作(PV操作) P操作：等待。如果sv大于0，减小sv。如果
python进程通信方式总结（一）：管道与信号量
submarineas的博客
02-14 2619
进程介绍 一个独立进程不受其他进程执行的影响，而一个协作进程可能会受到其他执行进程的影响，尽管可以认为那些独立运行的进程将非常高效地执行，但实际上，在许多情况下，可以利用合作性质来提高计算速度，便利性和模块化。进程间通信（IPC）是一种机制，允许进程彼此通信并同步其动作。这些过程之间的通信可以看作是它们之间进行合作的一种方法。 进程主要通过以下两者相互通信： 共享内存 讯息传递 而在实际使用情况中，我们又可以将其分为7种，如下图所示： 下面就对上面列举的方式在python中进行逐个说明，可能我理解的内
linux 进程间通信信号量,Linux进程间通信（四）信号量
weixin_32616935的博客
04-30 133
虽然本文是记录使用信号量保证进程的同步与互斥的，但是其实也可以看做是进程之间的通信问题，为了与前面的保持一致，所以还是叫做 Linux进程间通信了 (强迫症...)信号量基本概念进程间通信的方式有管道、消息队列、共享内存这些都是进程间的信息通信，而信号量可以理解为进程使用的临界资源的状态说明，信号量主要用于保证同步与互斥临界资源：两个进程看到的一份公共资源称之为临界资源临界区：各个进程中访问临界资...
Linux操作系统分析（10） - 进程通信之管道与信号量
897371388
09-24 183
提要 Linux中进程间的通信机制主要有：管道FIFO，信号量，消息，共享内存区，套接字。程序员在使用中可以根据不同的需求进行选择。 管道 管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。一个缓冲区不需要很大，它被设计成为环形的数据结构，以便管道...
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存
爱的海洋
04-19 856
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存 参考：《linux编程从入门到精通》,《Linux C程序设计大全》,《unix环境高级编程》 参考：C和指针学习 说明：本文非常的长，也是为了便于查找和比较，所以放在一起了 Linux 传统的进程间通信有很多，如各类管道、消息队列、内存共享、信号量等等。但它们都无法介于内核态与用户态使用，原因如表 通信方法 无法介于...
linux、windows下的进程间的通信方式、线程间的通信方式
ldw662523的博客
03-22 1242
Linux进程间的通信方式：管道、有名管道、信号量、消息队列、共享内存、信号、socket Windows进程间的通信方式：管道、信号量、消息队列、共享内存、socket Linxu线程间的通信方式：互斥量、条件变量、信号量、信号 Windows线程间的通信方式：互斥量、信号量、事件（Event）、临界区(Critical Section)...
Linux 管道通信
阿修罗道
09-09 6905
一、定义   管道是单向的、先进先出的。它将一个程序的输入和另一个程序的输出连接起来。数据被一个进程读出后，将被从管道中删除。分为无名和有名管道两种。前者用于父进程和子进程间的通信，后者用于同一系统的两个进程间通信。   二、无名管道      int  pi
【进程间通信】管道、信号量
min_xi的博客
07-29 292
管道： 有名管道：任意两个进程之间通信mkfifo 无名管道:父子进程之间通信pipe 写入管道的数据放在哪里？数据在内存中 通信方式：半双工（单工，半双工，全双工） 实现：读完才能覆盖 程序中：管道有固定的读端和写端 无名管道： 管道是基于文件描述符的通信方式，当一个管道建立时，它会创建两个文件描述符fd[0]和fd[1]，其中fd[0]固定用于读管道，而fd[1]...
操作系统-进程通信（信号量、匿名管道、命名管道、Socket）
12-06 208
进程通信（信号量、匿名管道、命名管道、Socket） 具体的概念就没必要说了，参考以下链接。 信号量 匿名管道 命名管道 Socket Source Code： 1. 信号量（生产者消费者问题） 1 #include <iostream> 2 #include <Windows.h> 3 #include <proc...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值