Linux进程间通信

最新推荐文章于 2024-07-15 10:12:43 发布
最新推荐文章于 2024-07-15 10:12:43 发布
阅读量961 收藏 28
点赞数 30
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59238924/article/details/140046742
版权

一、管道（pipe）

可概括为：两个人写纸条，一个写完放纸条，一个拿走纸条才读

1.无名管道

1.特点

1.它是半双工的（即数据只能在一个方向上流动），具有固定的读端和写端。

2.它只能用于具有亲缘关系的进程之间的通信（也是父子进程或者兄弟进程之间）。

3.它可以看成是一种特殊的文件，对于它的读写也可以使用普通的read、write 等函数。但是它不  是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。

 2.原型

  #include <unistd.h>

  int pipe2(int pipefd[2], int flags);

3.示例代码

int main()
{
char *str="Jin tian shi meihaode yitian!";
char buf[128];
int fd[2];
int pid;
if(pipe(fd)==-1)
{
        printf("creat pipe is failed !\n");
}

pid=fork();

if(pid<0)
{
        printf("Creat child is failed !\n");
}
else if(pid>0)
{       sleep(2);
        printf("This is father !\n");

        close(fd[0]);
        write(fd[1],str,strlen(str));
        wait();
}
else
{
        printf("This is child !\n");

        close(fd[1]);
        read(fd[0],buf,128);

        printf("Read from father is: %s\n",buf);
        exit(-1);
}
return 0;

}

需要注意的是，在进行写入或读取操作时，必须关掉另一个操作。

2.有名管道

   1.特点

  1. FIFO可以在无关的进程之间交换数据，与无名管道不同。

  2. FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

   2.原型

  #include <sys/stat.h>  

 // 返回值：成功返回0，出错返回-1

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

char buf[30];
int ret=mkfifo("./file",0600);
if(ret==-1)
 {
        printf("mkfifo is failed !\n");
        perror("why");
 }

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。

若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

 int fd = open("./file",O_RDONLY);
 printf("Open is success!\n");

若没有指定O_NONBLOCK时，只写open要阻塞到某个其他进程为读而打开它。

3.示例代码

读取操作

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
{

char buf[30];
int ret=mkfifo("./file",0600);
if(ret==-1)
 {
        printf("mkfifo is failed !\n");
        perror("why");
 }

 int fd = open("./file",O_RDONLY);
 printf("Open is success!\n");

 int nread=read(fd,buf,30);
 printf("Read %d byte from fifo,Context is: %s\n",nread,buf);

close(fd);
return 0;
}

在执行读取操作后，程序会卡住，直到其他进程进入才会往下执行。

写入操作

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include<fcntl.h>
int main()
{

 char * str="This is fifo message!";
 int fd = open("./file",O_WRONLY);
 printf("Write open is success!\n");
 write(fd,str,strlen(str));

close(fd);
return 0;
}

二、消息队列

可概括为：

A 放入纸条 B读纸条不拿走
B 放入纸条 A读纸条不拿走      是有效的交流方式

1.特点

  1. 消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。

  2. 消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。

  3. 消息队列可以实现消息的随机查询,消息不一定要以先进先出的次序读取,也可以按消息的类型读取。

2.原型

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

       int msgget(key_t key, int msgflg);
       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);                                                   ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
                      int msgflg);

key:

        key_t key;

        key=ftok(".",1);

3.示例代码

读取操作

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
//       int msgget(key_t key, int msgflg);
//       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//     ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
//                      int msgflg);
       struct msgbuf {
            long mtype;       /* message type, must be > 0 */
            char mtext[128];    /* message data */
           };
int main()
{
 struct msgbuf readbuf;
 struct msgbuf sendbuf={888,"Ni ye feichang shuai!\n"};
 int msgid=msgget(0x1234,IPC_CREAT|0777);
 if(msgid==-1)
 {
        printf("creat failed !\n");
 }

 msgrcv(msgid,&readbuf,sizeof(readbuf.mtext),888,0);
 printf("The first Read from que is :%s\n",readbuf.mtext);
 msgsnd(msgid,&sendbuf,strlen(sendbuf.mtext),0);

return 0;
}

写入操作

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

//       int msgget(key_t key, int msgflg);
//       int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
//     ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
//                      int msgflg);
       struct msgbuf {
            long mtype;       /* message type, must be > 0 */
            char mtext[128];    /* message data */
           };
int main()
{
 struct msgbuf sendbuf={888,"Wang jiahao feichang shuai!\n"};
 struct msgbuf readbuf;
 int msgid=msgget(0x1234,IPC_CREAT|0777);
 if(msgid==-1)
 {
        printf("creat failed !\n");
 }
 msgsnd(msgid,&sendbuf,strlen(sendbuf.mtext),0);
 msgrcv(msgid,&readbuf,sizeof(readbuf.mtext),888,0);
 printf("The Next Return from is  :%s\n",readbuf.mtext);


return 0;
}

三、共享内存

可概括为： A写消息到纸条，然后B直接读  

1.特点

  • 共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。

  • 因为多个进程可以同时操作，所以需要进行同步。

  • 信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问。

2.原型

1 #include <sys/shm.h>
2 // 创建或获取一个共享内存：成功返回共享内存ID，失败返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 连接共享内存到当前进程的地址空间：成功返回指向共享内存的指针，失败返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 断开与共享内存的连接：成功返回0，失败返回-1
7 int shmdt(void *addr); 
8 // 控制共享内存的相关信息：成功返回0，失败返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

过程 
a. 创建/打开共享内存
b.映射  把公共的内存 映射到 他们独自的内存空间
c.数据交换
d.释放共享内存
e.干掉共享内存

3.示例代码

shmw.c   写入操作

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
//       int shmget(key_t key, size_t size, int shmflg);
//       void *shmat(int shmid, const void *shmaddr, int shmflg);
//       int shmdt(const void *shmaddr);
//       int shmdt(const void *shmaddr);
//       int shmctl(int shmid, int cmd, struct shmid_ds *buf);
int main()
{
 char* shmaddr;
 int shmid;
 key_t key;
 key=ftok(".",1);

 shmid=shmget(key,1024*5,IPC_CREAT|0666);
 if(shmid==-1)
        {
        printf("Shmget is failed!\n");
        exit(-1);
        }
 shmaddr=shmat(shmid,0,0);
 printf("Shmat is ok!\n");

 strcpy(shmaddr,"Wang jiahao hen shuai!\n");
 sleep(5);
 shmdt(shmaddr);
 shmctl(shmid, IPC_RMID,0);
 printf("Finish!\n");
return 0;
}

shmr.c  读取操作

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
//       int shmget(key_t key, size_t size, int shmflg);
//       void *shmat(int shmid, const void *shmaddr, int shmflg);
//       int shmdt(const void *shmaddr);
//       int shmdt(const void *shmaddr);
//       int shmctl(int shmid, int cmd, struct shmid_ds *buf);
int main()
{
 char* shmaddr;
 int shmid;
 key_t key;
 key=ftok(".",1);

 shmid=shmget(key,1024*5,IPC_CREAT|0666);
 if(shmid==-1)
        {
        printf("Shmget is failed!\n");
        exit(-1);
        }
 shmaddr=shmat(shmid,0,0);
 printf("Shmat is ok!\n");
 printf("Context is :%s\n",shmaddr);
 shmdt(shmaddr);
 printf("Ok!\n");
return 0;
}

四、信号

1.原型

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);


2.示例代码

信号处理函数

#include <stdio.h>
#include <signal.h>
//      typedef void (*sighandler_t)(int);
//      sighandler_t signal(int signum, sighandler_t handler);
void handler(int signum)
{
 printf("Get signum is %d\n",signum);
        switch(signum)
        {
                case 2:
                printf("SIGINT\n");
                printf("Never killed!\n");
                break;
                case 10:
                printf("SIGUSR1\n");
                break;
        }
}
int main()
{
 signal(SIGINT,handler);
 signal(SIGUSR1,handler);

 while(1);
return 0;
}

信号发送 处理函数

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

       int kill(pid_t pid, int sig);

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

//  int kill(pid_t pid, int sig);
int main(int argc,char**argv)
{
        printf("qing shuru signum and pid !\n");
        int signum;
        int pid;
        char cmd[128]={0};
        signum=atoi(argv[1]);
        pid=atoi(argv[2]);

        printf("sginum is :%d,pid is :%d\n",signum,pid);

        kill(pid,signum);
//      sprintf(cmd,"kill -%d %d",signum,pid);

//      system(cmd);
        printf("Send signal is success!\n");

        return 0;
}

第二种方法 通过使用System调用cmd脚本

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

//  int kill(pid_t pid, int sig);
int main(int argc,char**argv)
{
        printf("qing shuru signum and pid !\n");
        int signum;
        int pid;
        char cmd[128]={0};
        signum=atoi(argv[1]);
        pid=atoi(argv[2]);

        printf("sginum is :%d,pid is :%d\n",signum,pid);

//      kill(pid,signum);
        sprintf(cmd,"kill -%d %d",signum,pid);

        system(cmd);
        printf("Send signal is success!\n");

        return 0;
}

五、高级信号处理

1.原型

       #include <signal.h>

       int sigaction(int signum, const struct sigaction *act,  struct sigaction *oldact);

函数名               void     (*sa_sigaction)(int, siginfo_t *, void *);
                        act.sa_sigaction=handler;
                        act.sa_flags=SA_SIGINFO;

  void handler(int signum, siginfo_t *info, void *context)
{
        printf("Get signum is :%d\n",signum);

        if(context !=NULL)
        {
                printf("Get data =%d\n",info->si_int);
                printf("Get data =%d\n",info->si_value.sival_int);
                printf("From pid is %d\n",info->si_pid);
        }
}

2.示例代码

信号处理

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

//       int sigaction(int signum, const struct sigaction *act,
//                   struct sigaction *oldact);

  void handler(int signum, siginfo_t *info, void *context)
{
        printf("Get signum is :%d\n",signum);

        if(context !=NULL)
        {
                printf("Get data =%d\n",info->si_int);
                printf("Get data =%d\n",info->si_value.sival_int);
                printf("From pid is %d\n",info->si_pid);
        }
}

int main()
{
        struct sigaction act;
        printf("This pid is %d\n",getpid());
        act.sa_sigaction=handler;
        act.sa_flags=SA_SIGINFO;

        sigaction(SIGUSR1,&act,NULL);
        while(1);
return 0;

}

信号发送处理代码

//       int sigqueue(pid_t pid, int  sig,  const  union  sigval value);

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



int main(int argc,char**argv)
{

        int signum;
        int pid;

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

         union  sigval value;
         value.sival_int=200;
//       int sigqueue(pid_t pid, int  sig,  const  union  sigval value);

        sigqueue(pid,signum,value);
        printf("Send pid is:%d\n Done",getpid());
        return 0;
}

六、信号量

1.特点

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

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

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

  4. 支持信号量组。

2.原型

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

      //1 daibiao you 1 ge xinhaoliang

      semid=semget(key,1,IPC_CREAT|0666);//creat huo get xinhaoliang

        union semun seminit;
        seminit.val=1;  // biaoshi you 1 ba suo
                //0 daibiao shuzu di 0 ge 
        semctl(semid,0,SETVAL,seminit);
 

//     int semctl(int semid, int semnum, int cmd, ...);
           union semun {
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
           };
只需要对 val进行操作即可

 seminit.val=0;  // 代表有几把锁  

3.示例代码

P操作

void GetKey(int id)
{
        struct sembuf sop;
        sop.sem_num=0;//bianhao  moren wei 0
        sop.sem_op=-1;
        sop.sem_flg=SEM_UNDO;
        semop(id,&sop,1);// 1 daibiao shuzu geshu
        printf("Get Key!\n");
}

V操作

void PutbackKey(int id)
{
        struct sembuf sop;
        sop.sem_num=0;//bianhao  moren wei 0
        sop.sem_op=1;
        sop.sem_flg=SEM_UNDO;
        semop(id,&sop,1);// 1 daibiao shuzu geshu
        printf("Putback the Key!\n");
}

总代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
//     int semget(key_t key, int nsems, int semflg);
//     int semctl(int semid, int semnum, int cmd, ...);
//     int semop(int semid, struct sembuf *sops, unsigned nsops);
//     int semtimedop(int semid, struct sembuf *sops, unsigned nsops,
//                   struct timespec *timeout);
  union semun {
               int              val;    /* Value for SETVAL */
               struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
               unsigned short  *array;  /* Array for GETALL, SETALL */
               struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                           (Linux-specific) */
       };
void GetKey(int id)
{
        struct sembuf sop;
        sop.sem_num=0;//bianhao  moren wei 0
        sop.sem_op=-1;
        sop.sem_flg=SEM_UNDO;
        semop(id,&sop,1);// 1 daibiao shuzu geshu
        printf("Get Key!\n");
}
void PutbackKey(int id)
{
        struct sembuf sop;
        sop.sem_num=0;//bianhao  moren wei 0
        sop.sem_op=1;
        sop.sem_flg=SEM_UNDO;
        semop(id,&sop,1);// 1 daibiao shuzu geshu
        printf("Putback the Key!\n");
}
int main(int argc,char *argv[])
{
        int semid;
        key_t key;
        key=ftok(".",1);
                //1 daibiao you 1 ge xinhaoliang
        semid=semget(key,1,IPC_CREAT|0666);//creat huo get xinhaoliang
        union semun seminit;
        seminit.val=0;  // biaoshi you 1 ba suo
                //0 daibiao shuzu di 0 ge 
        semctl(semid,0,SETVAL,seminit);
        int pid=fork();
        if(pid>0)
        {
        //qusuo
                GetKey(semid);
                printf("This is father !\n");
        //huansuo
                PutbackKey(semid);
        //xiaohui suo
                semctl(semid,0,IPC_RMID);
        }
        else if(pid ==0)
        {
                printf("This is child !\n");
        //huansuo
                PutbackKey(semid);
        }
        else
        {
                printf("Fork is failed!\n");
        }
        return 0;
        }

火鸡味の锅巴
关注
  • 30
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
linux-linux进程间通信方式汇总.zip
02-26
在Linux操作系统中，进程间通信（IPC，Inter-Process Communication）是多个进程之间共享数据、交换信息的关键技术。本文将全面解析Linux中的各种进程间通信方式，帮助你深入理解这一核心概念。 首先，我们来了解...
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
Linux进程间通信--使用信号
09-15
Linux进程间通信是一种让不同进程之间交换信息或协调工作的方式，而在Linux系统中，信号（Signal）是一种简单但重要的通信机制。本文将深入探讨如何利用信号进行进程间通信。 首先，信号是操作系统用来通知进程发生...
【持续集成_05课_Linux部署SonarQube及结合开发项目部署】
weixin_42333261的博客
07-12 262
前置条件：sonarQube不能使用root账号进行启动，所以需要创建普通用户及。3）CMD上传qube文件-不能传到home路径下哦。2）添加用户、组名、密码。4）检查并解压上传的包。
Linux C | 管道open打开方式
I_feige的博客
07-12 316
1.
Linux 安装 Docker Compose
m0_63004677的博客
07-12 336
Linux 系统安装 Docker Compose
【Linux】 GCC/G++与Makefile使用
Long_kin的博客
07-11 1008
收藏向 使用解析
Linux --- 高级IO
V_zjs的博客
07-12 828
Linux --- 高级IO
Linux笔记之shell终端命令后显示指定行数的grep和head
小勇博客
07-14 497
在Linux中，grep命令和head命令常用于文本处理。grep命令用于搜索文本中的特定模式，而head命令用于显示文件的开头部分。了解如何结合这两个命令（例如使用管道）可以帮助你更高效地处理和查看文本数据。grep -A选项用于在匹配到的行之后显示指定数量的行。例如，将显示匹配到的行及其后面的三行。选项用于显示文件的前n行。例如，将显示file.txt的前五行。
Linux 入门教程 by 程序员鱼皮
努力做最接地气的编程干货分享，感谢关注
07-11 795
对初学 Linux 的同学来说，一般不会部署特别大的项目，1 核 1 G 的服务器，无论是用来学习 Linux 命令，还是用来部署个人博客和小项目都已经足够了。后续如果需要用到更高的配置，再升级即可。
【Linux 线程】线程的基本概念、LWP的理解
Hou_lang_LJ的博客
07-10 425
🐧① Linux 线程的基本概念；
第一节Linux常见指令
最新发布
2202_75331338的博客
07-15 598
tail命令从指定点开始将文件写到标准输出，使用tail命令的 -f 选项可以方便的查阅正在改变的日志文件，tail -f filename 会把 filename 里最尾部的内容显示在屏幕上，并且不但刷新，使你看到最新的文件内容。说明：cp指令用于复制文件或目录，如同时指定两个以上的文件或目录，且最后的目的地是一个已经存在的目录，则它会把前面指定的所有文件或目录复制到此目录中，若同时指定多个文件或目录，而最后的目的地并非一个已存在的目录，则会出现错误信息。公历是选择国际通用的历法，又称格列历，通称阳历。
【Linux】centos7安装PHP7.4报错：libzip版本过低
m0_52985087的博客
07-12 343
原因：当前服务器libzip的版本小于0.11比较低，需要更新升级，而且libzip升级版本不能是1.3.1,1.7.0的。安装完成后，查看是否存在/usr/local/lib/pkgconfig目录,如果存在，验证是否卸载成功：rpm -qa|grep libzip，如无输出信息则卸载成功。也可以直接在download后直接拼接要下载的libzip的版本。注意：只是在当前的shell会话中设置了这个环境变量。验证libzip：whereis libzip。查看服务器上libzip的版本。
windows 中的 Nsight Systems 通过ssh 链接分析 Linux 中的cuda程序性能
eloudy的专栏
07-12 155
安装 ssh-server安装较新版本的 cuda sdk下载cuda-samples github repo编辑修改 ssh 配置：删除相关注释，修改后如下：Port 22。
Linux中六种常见工具
qhy850716的博客
07-13 1114
允许使用者通过命令进行文本编辑控制。
termux 安装 rockylinux
欢迎来到别往的博客
07-13 349
往找最新的文件目录,选择ARM版本的image。或者直接查看目录或者国内阿里云镜像,按照cpu架构(安卓9手机一般是aarch64arm最新架构)，获取镜像地址，以及checksum里的SHA256信息更新到以下rocky9.sh脚本，如果不需要直接使用即可。
【Linux】权限管理与相关指令
m0_52602233的博客
07-13 952
Linux权限管理、linux用户角色、linux文件属性、linux文件权限、linux文件类型、linux目录权限、linux粘滞位、linux umask文件掩码、linux文件权限八进制数值、linux权限指令、linuxLinux -rwx的理解 linux su sudo chmod chown chgrp umask whoami file

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

火鸡味の锅巴

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值