进程间通信

最新推荐文章于 2020-11-27 16:54:57 发布
最新推荐文章于 2020-11-27 16:54:57 发布
阅读量253 收藏
点赞数 1
分类专栏： Linux 进程间通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alsnoa/article/details/80496510
版权

1.使用管道进行通信

 server 创建管道mypipe,并以只读方式打开.  

 client 以只写方式打开管道.   

 两者借助管道进行通信，若有一方退出，则另一方也退出。

server.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
#define ERR_EXIT(m) \
do {\
     perror(m);\
     exit(EXIT_FAILURE);\
   }while(0)

int main()
{
  umask(0);
  if(mkfifo("mypipe", 0644)< 0)
  {
      ERR_EXIT("mkfifo");
  }
  int rfd=open("mypipe",O_RDONLY);
   if(rfd<0)
   {
       ERR_EXIT("open");
   }
   char buf[1024];
   while(1)
   {
       printf("Please wait....\n");
       ssize_t s=read(rfd,buf,sizeof(buf)-1);
       if(s>0)
       {
           buf[s-1]=0;
           printf("Client say# %s\n", buf);
       }
       else if(s==0)
       {
           printf("client quit,exit now!\n");
           exit(EXIT_SUCCESS);
       }
       else
       {
           ERR_EXIT("read");
       }
       
   }
   close(rfd);
   return 0;
}

client.c

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

#define ERR_EXIT(m)\
    do{\
    perror("m");\
    exit(EXIT_FAILURE);\
    }while(0)

int main()
{
    int wfd=open("mypipe",O_WRONLY);
    if(wfd<0)
    {
        ERR_EXIT("open");
    }
    
    char buf[1024];
    while(1)
    {
        buf[0]=0;
        printf("Please enter#");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1); 
        if(s>0)
        {
            buf[s]=0;
            write(wfd, buf, strlen(buf));
        }
        else
        {
            ERR_EXIT("read");
        }
    }

    close(wfd);
    return 0;
}
result

管道内置了同步互斥的机制，读写操作互斥进行，保证了通信的可靠性。



2.使用消息队列进行通信

说明：

1.server 创建消息队列，并且等待client 发送消息，接收到client发的消息后，再向client发送消息。

   client 得到消息队列， 向server发送消息，之后接受server的消息。


2. msgsnd和msgrcv系统调用函数都内置了同步互斥的机制，

  如果没有可发送的消息msgsnd就会自己阻塞。

  如果没有可接受的消息msgrcv就会自己阻塞。


3.关于msgget（）中flag的说明：

server 的 flag：IPC_CREAT | IPC_EXCL | 0644

client  的 flag：IPC_CREAT

IPC_CREAT | IPC_EXCL 表示想要获得一个全新的消息队列标识符，如果对应的key已经被占用，则错误返回负数值。0644是权限设置。

IPC_CREAT表示如果对应的key已经被占用，就得到key对应的消息队列标识符，如何key未被占用就，创建新的消息队列。

由于client 中 flag 未对消息队列的权限做出设置，所以之后对消息队列的 msgsnd 和 msgrcv 操作会出现 “没有权限访问”的相关错误。
所以server必须首先运行，为获得一个全新的消息队列。

comm.h

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

#define PATHNAME "."
#define PROJ_ID 0x6666

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

struct msgbufs
{
  long mtype;
  char mtext[1024];
};

int creatMsgQueue();

int getMsgQueue();

int destroyMsgQueue(int msgid);

int sendMsg(int msgid, int who ,char *msg);

int recvMsg(int msgid, int recvType, char out[]);

comm.c

#include"common.h"

//success > 0 failed==-1

static int commMsgQueue(int flags)
{
 
    key_t _key=ftok(PATHNAME,PROJ_ID);
   
    if(_key<0)
    {
       perror("ftok");
       return -1;
    }

    int msgid=msgget(_key,flags);

    if(msgid<0)
    {
       perror("msgget");
    }
   
    return msgid;

}

int creatMsgQueue()
{
    return commMsgQueue (IPC_CREAT|IPC_EXCL|0666);
}

int getMsgQueue()
{
    return commMsgQueue(IPC_CREAT);
}

int destroyMsgQueue(int msgid)
{
    if(msgctl(msgid,IPC_RMID,NULL)<0)
    {
        perror("msgctl");
        return -1;
    }
    return 0;
}

int sendMsg(int msgid,int who ,char *msg)
{
    struct msgbufs buf;
    buf.mtype=who;
    strcpy(buf.mtext,msg);

    if(msgsnd(msgid,(void*)&buf,sizeof(buf.mtext),0)<0)
    {
        perror("msgsnd");
        return -1;
    }
    return 0;
}

int recvMsg(int msgid, int recvType,char out[])
{
    struct msgbufs buf;
    if(msgrcv(msgid,(void*)&buf,sizeof(buf.mtext),recvType ,0)<0)
    {
        perror("msgrcv");
            return -1;
    }
    strcpy(out,buf.mtext);
    return 0;

}

server.c

#include<unistd.h>
#include"common.h"

int main()
{
    int msgid=creatMsgQueue();
    char buf[1024];
    while(1)
    {
        buf[0]=0;
        recvMsg(msgid,CLIENT_TYPE,buf);
        printf("cilent# %s\n", buf);

        printf("Please Enter#");
        fflush(stdout);
        ssize_t s= read(0,buf,sizeof(buf));
        if(s>0)
        {
            buf[s-1]=0;
            sendMsg(msgid,SERVER_TYPE,buf);
            printf("send done,wait recv...\n");
        }
    }
    destroyMsgQueue(msgid);
    return 0;
}

client.c

#include<unistd.h>
#include"common.h"

int main()
{
    int msgid=getMsgQueue();

    char buf[1024];
    while(1)
    {
        buf[0]=0;
        printf("Please Enter#");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf));
        if(s>0)
        {
            buf[s-1]=0;
            sendMsg(msgid,CLIENT_TYPE,buf);
            printf("send some.wait recv...\n");

        }
        recvMsg(msgid,SERVER_TYPE,buf);
        printf("server# %s\n",buf);
    }
    return 0;

}

result


3.共享内存通信

server创建共享内存，得到shmid标识符，并将共享内存通过shmat（）函数挂接到server进程虚拟地址空间的共享内存区域。

server来打印共享内存中的内容。

client获取共享内存，得到shmid标识符，并将共享内存通过shmat（）函数挂接到client进程虚拟地址空间的共享内存区域。

client向共享内存中写入数据。

此时client就和server通过共享内存进行通信了。

注意：
1.shmat后两个参数表示 在挂接过程中 共享内存区开始映射的起始地址的偏移量。
2.在程序退出之前，要调用 shmdt （）来取消进程虚拟地址空间月共享内存的映射关系。

comm.h

#pragma once

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

#define PATHNAME "."
#define PROJ_ID 0x6666

int createShm(int size);

int destroyShm(int shmid);

int getShm(int size);

comm.c

#include"comm.h"

static int commShm(int size,int flags)
{
    key_t _key=ftok(PATHNAME, PROJ_ID);
    if(_key<0)
    {
        perror("shmget");
        return -1;
    }

    int shmid=0;

    if((shmid=shmget(_key,size,flags))<0)
    {
        perror("shmget");
        return -2;
    }

    return shmid;
}

int destroyShm(int shmid)
{
    if(shmctl(shmid,IPC_RMID,NULL)<0)
    {
        perror("shmctl");
        return -1;
    }
    return 0;

}

int createShm(int size)
{
    return commShm(size,IPC_CREAT|IPC_EXCL|0666);

}

int getShm(int size)
{
    return commShm(size,IPC_CREAT);
}

server.c

include<unistd.h>
#include"comm.h"

int main()
{
    int shmid=createShm(4096);
    char *addr=(char*)shmat(shmid,NULL,0);
    sleep(2);
    int i=0;
    while(i<26)
    {
        printf("client# %s \n",addr);
        sleep(1);
        i++;
    }
    shmdt(addr);
    sleep(2);
    destroyShm(shmid);
    return 0;
}

client.c

#include<unistd.h>
#include"comm.h"

int main()
{
    int shmid=getShm(4096);
    sleep(1);
    char *addr=shmat(shmid,NULL,0);
    sleep(2);
    int i=0;
    while(i<26)
    {
        addr[i]='A'+i;
        i++;
        addr[i]=0;
        sleep(1);

    }
    shmdt(addr);
    sleep(2);
    return 0;

}

与消息队列创建的原理相同 , server需要首先运行，创建共享内存。

result：


4.信号量的使用 与 静态库和动态库的打包。


1. 关于参数 nums 在不同函数中的意义不同：
   1.在 semget（）的中的第二个参数nums表示 ：在这个即将创建的信号量集合中 要创建 几个信号量。
  （一个信号量集合中可以创建多个信号量）------flag 为 ( IPC_CREAT | IPC_EXCL | 0666)
   2.如果semget（）的 flag 为 (IPC_CREAT )，表示要获得该信号量集合的id。
    那么第二个参数  nums  必须要 小于等于 key所对应的信号量集合的nums，否则出错返回负数值。
  3.在 semctl()的第二个参数中的nums 表示要对信号量集合中第几个信号量进行操作（信号量集中的信号量标号从 0 开始）
     所以 nums 必须 小于 之前semget输入的nums 。
      例如 在semget（）中 nums为1，那么在 semctl 中 nums必须为 0。
2. semop()函数中 后两个参数的使用说明：
   第二个参数 sembuf * buf 表示结构体数组的指针。
   第三个参数表示结构体数组的大小 ，因为可能对多个信号量进行操作。结构体数组中的每一个元素，表示对一个信号量进行操作。

即 ：第二个参数传递数组的指针 ，第三个参数传递数组的大小。

comm.h

#pragma once

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

#define PATHAME "."
#define PROJ_ID 0x6666

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

int createSemSet(int nums);

int initSem(int semid,int nums, int initVal);

int getSemSet(int nums);

int P(int semid, int Who);

int V(int semid,int Who);

int destroySemSet(int semid);

comm.c

#include"comm.h"

static int commSemSet(int nums,int flags)
{
    key_t _key=ftok(PATHAME,PROJ_ID);
  if(_key<0)
  {
      perror("ftok");
      return -1;
  }
  int semid=semget(_key,nums,flags);
     if(semid<0)
     {
         perror("semget");
         return -2;
     }
     return semid;

}

int createSemSet(int nums)
{
    return commSemSet(nums,IPC_CREAT|IPC_EXCL|0666); 
}

int getSemSet(int nums)
{
    return commSemSet(nums,IPC_CREAT);
}

int initSem(int semid ,int nums,int initVal)
{

     union semun _un;
     _un.val=initVal;

    if(semctl(semid, nums, SETVAL, _un)<0)
    {
        perror("semctl");
        return -1;
    }

    return 0;
}
static int commPV(int semid, int who ,int op)
{
    struct sembuf _sf;
    _sf.sem_num=who;
    _sf.sem_op=op;
    _sf.sem_flg=0;

    if(semop(semid, &_sf, 1)< 0)
    {
        perror("semop");
        return -1;
    }
    return 0;

}

int P(int semid, int Who)
{
    return commPV(semid,Who,-1);
}

int V(int semid,int who)
{
    return commPV(semid,who,1);

}

int destroySemSet(int semid)
{
    if(semctl(semid,0, IPC_RMID)<0)
    {
        perror("semctl");
        return -1;
    }
   return 0;
}

test_sem.c

#include<sys/types.h>
#include<sys/wait.h>
#include<unistd.h>
#include<stdio.h>
#include"comm.h"

int main()
{
    int semid=createSemSet(1);
    initSem(semid,0,1);
    pid_t id=fork();
    if(id==0)
    {
        int _semid=getSemSet(0);
         while(1)
         {
             P(_semid,0);
             printf("A");
             fflush(stdout);
             usleep(123456);
             printf("A");
             fflush(stdout);
             usleep(321456);
             V(_semid,0);
         }
    }
    else
    {
        while(1)
        {
            P(semid,0);
            printf("B");
            fflush(stdout);
            usleep(223456);
            printf("B");
            fflush(stdout);
            usleep(121456);
            V(semid,0);
        }
        wait(NULL);
    }
    destroySemSet(semid);
     return 0;
}

打包静态库：

1. 执行命令 gcc  -c  comm.c  生成 comm.o
2. 执行命令 ar cr libmypv.a comm.o 生成静态库
3.执行命令 gcc -o test1 test_sem.c -L. -lmypv  （之后可以删除libmypv.a）
4.运行 test1

打包动态库：

1.删除之前的comm.o 。
2.执行命令 gcc -fPIC -c comm.c 生成与地址无关的 comm.o文件。
3.执行命令  gcc -shared  -o libmypv.so comm.o 生成动态库文件。
4.执行命令  mv libmypv.so /usr/lib64/  将动态库文件移入 /usr/lib64 系统索引库中。
5.执行命令 gcc -o test2 test_sem.c -L. -lmypv
6.运行test2 

result：
5.关于系统中共享 资源的查看与删除

 1.可以通过指令  ipcs  列出系统中所有 共享资源 的相关信息。
 2.可以通过指令  ipcrm  -q / -m / -s  + 资源id   分别删除对  消息队列、共享内存、信号量 共享资源进行删除。


6.对生产者与消费者模型与同步互斥的理解


  生产者：写入信息到共享的资源中。

    在写入操作之前，生产者会检查 ：

   1 .共享资源是否被写满 ？如果共享资源已经被写满，生产者就阻塞的等待，直到有消费者读取了其中的资源后，再进行写入。

   2. 是否有消费者对该共享资源进行读取？ 如果有就阻塞的等待直到到消费者读取完毕。如果没有就直接写入。

  

  消费者：读取信息从共享的资源中。

    再读取操作之前，消费者会检查：

   1.共享资源是否为空？ 如果共享资源为空，消费者就阻塞的等待，直到有生产者对共享资源写入后，再进行读取。

   2.是否有生成者对其写入？ 如果有，就阻塞的等待直到生成者写入完毕，再进行读取。

  这样的机制使得生产者和消费者在对共享资源进行操作的时由于互斥的访问机制，使得他们对内容获取具有了同步性。



Alsnoa
关注
专栏目录
linux c++的一个简单的server和client通信
qingqiulengya的博客
01-10 597
//server.c #include<stdio.h> #include<unistd.h> #include<sys/socket.h> #include<netinet/in.h> #include<stdlib.h> #include<arpa/inet.h> #include<string.h&...
linux高级程序设计——进程
qq_45745843的博客
11-30 550
进程的定义 程序： 程序是存放在存储介质上的一个可执行文件。 进程： 进程是程序的执行实例，包括程序计数器，寄存器和变量的当前值。程序是静态的，进程是动态的。 程序是一些指令的有序集合，而进程是程序执行的过程。进程是程序的一次执行过程。进程的状态是变化的，其包括进程的创建，调度和消亡。 只要程序运行，此时就是进程，程序每运行一次，就会创建一个进程。 在linux系统中，进程是管理事务的基本单元。 进程拥有自己独立的处理环境和系统资源（处理器，存储器，I/O设备，数据，程序）。 可用exec函数由内核将程序读
Linux基础学习—wait函数
Aaronlxx的博客
11-27 362
wait函数 头文件 #include<sys/types.h> #include<sys/wait.h> 函数原型 pid_t wait (int * status); 参数 status 是一个整形指针。如果status不是一个空指针,则终止进程的终止状态将存储在该指针所指向的内存单元中。如果不关心终止状态,可以将 status参数设置为NULL。 调用 wait 函数时,调用进程将会出现下面的情况: 如果其所有子进程都还在运行,则阻塞。 如果一个子进程已经终止,正等待父进程获
【Linux】进程间通信之消息队列
xiaoxianerqq的专栏
02-27 154
转自：https://blog.csdn.net/wei_cheng18/article/details/79661495   在上一篇博客里，我们学习了进程间通信的一种方式，那就是管道，今天我们继续学习另一种方式消息队列。 消息队列 一. 什么是消息队列？ 　　消息队列是消息的链表，存放在内核中并由消息队列标识符表示。  　　消息队列提供了一个从一个进程向另一个进程发送数据块的方法，每...
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
ipcs命令 多进程间通信常用的工具
01-09
ipcs命令是用于报告Linux中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息 。 语法格式：ipcs [参数] 常用参数： -a 默认的输出信息 -m 打印出使用共享内存进行进程间通信的信息 -q ...
LInux进程间通信——消息队列
qq_36971449的博客
10-24 120
消息队列：            消息队列提供了一个从一个进程向另一个进程发送一块数据的方法。            每个数据块被认为是有一个类型，接收者进程接受的数据块可以有不同的的类型值。            消息队列每个消息的最大长度是有限的，每个消息队列的总的字节数是有上限的，系统上消息队列的总数也有⼀个上限。   IPC对象：            IPC对象是活动在内核级...
Linux学习笔记16——wait函数
weixin_30823683的博客
07-27 216
wait函数的定义如下： #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *stat_loc); 　　wait系统调用将暂停父进程直到它的子进程结束为止，这个调用返回子进程的PID，它通常是已经结束运行的子进程的PID。状态信息允许父进程了解子进程的退出状态，即子进程的main函数返回的...
利用消息队列来实现IPC
06-25 3152
晚上在FC4下调试出了第一个linux程序，成功地运行，有点成就感，虽然这个程序是抄过来.        本程序的功能是利用系统V(Sys V)消息队列来实现进程间的通信(IPC).        简单地介绍程序:        用到的一个数据结构-------消息，用一个结构体来表示: struct msgbuf
进程间通信(IPC)之消息队列
Xiao__Tian__的博客
07-07 6541
漫谈进程间通信之消息队列，进程通信家族中不可或缺的一员。交流学习，共同进步。
Linux 进程间通信1.2 — 消息队列
qq_45831156的博客
08-15 228
前面我们所讲的 管道，不论是否匿名，都是半双工的，也就是说，一方只能读，一方只能写。 参考大佬博文 消息队列 消息队列，是消息的链表，存放在 内核中，一个消息队列由一个标识符（即 队列 ID）来表识。 特点 消息队列是面向记录的，其中的消息具有特定的格式及特定的优先级。 消息队列独立与发送与接收进程，进程终止时，消息队列及内容不会被删除。 消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按照消息的类型读取。 所以： a. B如何加消息？ b. A如何从队列拿消息？ 消息队.
进程间通信(二) 消息队列
wck0617
04-05 651
区别于管道 1.不同于管道面向字节流,它是以数据块为单位进行传送的(消息队列类似于网络通讯协议中的UDP,管道类似于TCP) 2.区别于管道生命进程随进程,消息队列的生命周期是随内核的 3.区别fifo管道的先进先出,消息队列读取是并行的 消息队列 消息队列是系统的ipc资源, 操作系统为每个ipc资源都统一维护了一个数据结构ipc_perm struct ipc_perm ...
static int 和 int 区别
热门推荐
爱技术....爱生活！
03-08 1万+
转自: 在函数里面声明： static int 静态变量（也可以称为全局变量，值一直存在），会在静态存储区只进行一次初始化，下次调用直接赋值 int  每次调用都初始化一次，分配不同的内存地址 void f1() { static int i; i=1; if(i==1) { MessageBox("a"); i=2; } } void f2() { static
通过共享内存，实现两个进程A,B之间的通信
wangshiqueque的专栏
07-30 6333
进程A： #include      #include      #include      #include      #include    #include    #include      #define SHM_SIZE    4096  #define SHM_MODE    (SHM_R | SHM_W) /* user read/write *
微服务架构中的进程间通信（交互方式、消息格式）
qq_24166417的博客
06-21 716
一、交互方式 在为服务选择的API选择进程间通信机制之前，首先要考虑服务与其客户端的交互方式。 交互方式的选择影响应用程序的可用性。 交互方式可以帮助选择合适的集成测试策略。 交互方式分为两个维度： 1、一对一和一对多 一对一：每个客户端请求由一个服务实例处理； 一对多：每个客户端请求由多个服务实例处理。 2、同步和异步 同步：客户端请求需要服务端实时响应，客户端等待响应时可能导致阻塞； 异步：客户端请求不会阻塞进程，服务端的响应可以是非实时的。 交互方式组合见表格：
Linux进程间通信机制详解
"Linux进程间通信的PPT，涵盖了进程间通信概述、管道通信、信号、共享内存和消息队列等内容，介绍了多种Unix和System V进程间通信方式以及POSIX标准的通信机制。" 在计算机系统中，进程间通信（Inter-Process ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值