System V IPC+消息队列

多进程与多线程

使用有名管道实现双向通信时,由于读管道是阻塞读的,为了不让“读操作”阻塞“写操作”,使用了父子进程来多线操作,
1)父进程这条线:读管道1
2)子进程这条线:写管道2

实际上:凡是涉及到多线操作的,基本都使用多线程来实现

1)主线程:读管道1
2)次线程:写管道2
  • 线程和进程都是并发运行的,但是线程和进程各自的使用的场合有所不同

    多线使用多线程更省计算机cpu和内存的开销

    创建出并发运行的线程目的-----------多线操作

程序必须要去运行一个新程序时,此时必须涉及到多进程

  • 这里并发运行的主要目的并不是为了多线操作,而是为了单独的去执行新程序

执行新程序时,我们只能使用多进程来操作,因为线程是不可能去执行一个新程序的

System V IPC

无名管道和有名管道都是UNIX系统早期提供的比较原始的一种进程间通信方式

后来Unix系统升级到第5版本时,又提供了三种新的IPC通信方式

  • 消息队列
  • 信号量
  • 共享内存

System V就是系统第5版本的意思

后来的Linux也继承了unix的这三个通信方式

管道的机制
  • 管道的本质就是一段缓存
  • Linux OS内核是以文件的形式来管理管道

我们都是使用文件描述符文件的形式来操作:无名管道和有名管道

操作管道时:
除了pipe和mkfifo这两个函数外,其它的像read、write、open都是文件io函数
System V IPC

System V IPC与管道有所不同:

它完全使用了不同的实现机制,与文件没任何的关系

也就是说内核不再以文件的形式来管理System V IPC

  • 对于System V IPC,OS内核提供了全新的API
  • System V IPC时,不存在亲缘进程一说,任何进程之间都可以使用System V IPC来通信
System V IPC标识符
  • 这个“标识符”就是文件描述符的替代者,但是它是专门给System V IPC使用的
  • 不能使用文件IO函数来操作“标识符”,只能使用System V IPC的特有API才能操作
如何得到ipc标识符

调用某API创建好某个“通信结构”以后,API就会返回一个唯一的“标识符”

比如创建好了一个“消息队列”后,创建的API就会返回一个唯一标识消息队列的“标识符”

ipc标识符作用

如果创建的是消息队列的话:

  • 进程通过消息队列唯一的标识符,就能找到创建好的“消息队列”

  • 使用这个消息队列,进程就能读写数据,从而实现进程间通信

可以读写数据就是实现了通信

也就是标识符就是可是识别传建好的system V IPC

消息队列

本质

消息队列的本质:由内核创建的用于存放消息的链表

由于是存放消息的,所以把这个链表称为了消息队列

如何存放消息

消息队列这个链表有很多的节点,链表上的每一个节点就是一个消息

System V IPC+消息队列_第1张图片

  • 注意是一个双向链表
  • 每个消息由两部分组成
    • 1)消息编号:识别消息用
    • 2)消息正文:真正的信息内容
发送接收消息过程
1.发送消息

(a)进程先封装一个消息包

(b)调用相应的API发送消息

这个消息包其实就是如下类型的一个结构体变量:
----封包时将消息编号和消息正文写到结构体的成员中
struct msgbuf{
				long mtype;         /* 放消息编号,必须> 0 */
				char mtext[msgsz];   /* 消息内容(消息正文) */
			};	
b过程:
1.调用API时通过“消息队列的标识符”找到对应的消息队列
2.将消息包发送给消息队列,消息包会被作为一个链表节点插入链表
2.接收消息

调用API接收消息时,必须传递两个重要的信息

  1. 消息队列标识符
  2. 你要接收消息的编号

有了这两个信息:

API就可以找到对应的消息队列,然后从消息队列中取出你所要编号的消息

收到了别人所发送的信息,实现了通信

“消息队列”有点像信息公告牌:
--------发送信息的人把某编号的消息挂到公告牌上
--------接收消息的人自己到公告牌上去取对应编号的消息
如此,发送者和接受者之间就实现了通信

----使用消息队列实现网状交叉通信很容易

----消息队列作为媒介,一个往双向链表发数据,一个根据编号取出数据

消息队列使用步骤

  1. 使用msgget函数

    • 消息队列不存在:创建新的消息队列

    • 消息队列存在:获取已存在的某个消息队列,并返回唯一标识消息队列的标识符(msqID)

      后续收发消息就是使用msqID这个标识符来实现的

  2. 收发消息

    • 发送消息:使用msgsnd函数,利用消息队列标识符发送某编号的消息
    • 接收消息:使用msgrcv函数,利用消息队列标识符接收某编号的消息
  3. 使用msgctl函数,利用消息队列标识符删除消息队列

对于使用消息队列来通信的多个进程来说:
        只需要一个进程来创建消息队列就可以了
对于其它要参与通信的进程来说:
        直接使用这个创建好的消息队列即可

  • 为了保证消息队列的创建,让每一个进程都包含创建消息队列的代码,谁先运行就由谁创建

  • 后运行的进程如果发现它想用的那个消息队列已经创建好了,就直接使用

  • 当众多进程共享操作同一个消息队列时,即可实现进程间的通信。

消息队列API

#include 
#include 
#include 
//功能:利用key值创建、或者获取一个消息队列
/*
1.如果key没有对应任何消息队列,那就创建一个新的消息队列
2.如果key已经对应了某个消息队列,说明消息队列已经存在了,那就获取这个消息队列来使用
*/
//msgflg:指定创建时的原始权限,比如0664
int msgget(key_t key, int msgflg);

key值--------用于为消息队列生成(计算出)唯一的消息队列ID

  • 第一种:指定为IPC_PRIVATE宏

    指定这个宏后,每次调用msgget时都会创建一个新的消息队列

  • 第二种:可以自己指定一个整形数,但是容易重复指定

  • 第三种:使用ftok函数来生成key

    #include 
    #include 
    /*
    ftok通过指定路径名和一个整形数,就可以计算并返回一个唯一对应的key值,
    ---------只要路径名和整形数不变,所对应的key值就唯一不变的
    */
    //ftok只会使用整形数(proj_id)的低8位,因此我们往往会指定为一个ASCII码值
    key_t ftok(const char *pathname, int proj_id);
    

    创建一个新的消息队列时,除了原始权限,还需要指定IPC_CREAT选项

    msgid = msgget(key, 0664|IPC_CREAT);
    
    • 创建一个新的消息队列,此时就会用到msgflg参数

多个进程如何共享同一个消息队列

  1. 创建进程
  • 创建者使用"./file", 'a’生成一个key值
  • 然后调用msgget创建了一个消息队列
key = ftok("./file", 'a');
msgid = msgget(key, 0664|IPC_CREAT);

当创建者得到msgid后,即可操作消息队列

  1. 实现共享

只要能拿到别人创建好的消息队列的ID,即可共享操作同一个消息队列,实现进程间通信

获取别人创建好的消息队列的ID,有两个方法:

a)创建者把ID保存到某文件,共享进程读出ID即可

这种情况下,共享进程根本不需要调用msgget函数来返回ID

b)调用msgget获取已在消息队列的ID

  • 使用ftok函数,利用与创建者相同的“路径名”和8位整形数,生成相同的key值
  • 调用msgget函数,利用key找到别人创建好的消息队列,返回ID
key = ftok("./file", 'a');
msgid = msgget(key, 0664|IPC_CREAT);						

这种方法是最常用的方法,因为ftok所用到的“路径名”和“8位的整形数”比较好记忆

代码演示

创建一个消息队列
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MSG_FIFE "./msgfile"
int  create_or_get_msgque(){
    //创建消息队列,返回msgid
     int msgId=-1;
     key_t key=-1;
     int fd=0;
     //为了用到文件路径名,用open创建
     fd=open(MSG_FIFE,O_RDWR|O_CREAT,0664);
     //用生成的路径+asc码生成唯一整数
     key=ftok(MSG_FIFE,'a');
     msgId=msgget(key,0664|IPC_CREAT);
     return msgId;
}
int main(void){
    int msgID=-1;
    int ret=-1;
    msgID=create_or_get_msgque();
    /*父子进程收发消息*/
    ret=fork();
    if(ret>0){//父进程发送消息

    }
    else if(ret==0){//子进程接收消息

    }
    return 0;
}

ipcs命令:

  • a 或者 什么都不跟:消息队列、共享内存、信号量的信息都会显示出来
  • m:只显示共享内存的信息
  • q:只显示消息队列的信息
  • s:只显示信号量的信息

System V IPC+消息队列_第2张图片

system v ipc的缺点:

进程结束时,system v ipc不会自动删除,进程结束后,使用ipcs依然能够查看到。

如何删除消息队列

  • 方法1:重启OS,很麻烦
  • 方法2:进程结束时,调用相应的API来删除
  • 方法3:使用ipcrm命令删除
ipcrm命令
 删除共享内存
 ----+M:按照key值删除   ipcrm -M key
 ----+m:按照标识符删除   ipcrm -m msgid
 删除消息队列
-----+Q:按照key值删除
-----+q:按照标识符删除
删除信号量
-------+S:按照key值删除
-------+s:按照标识符删除

msgsnd()

#include 
#include 
#include 
//功能:将消息挂到消息队列上
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

四个参数:

  • msqid:消息队列的标识符
  • msgp:存放消息的缓存的地址,类型struct msgbuf类型

这个缓存就是一个消息包(存放消息的结构体变量)

struct msgbuf {
               long mtype;       /* message type, must be > 0 */
               char mtext[1];    /* message data */
              };
  • msgsz:消息正文大小

  • msgflg

  • 0:阻塞发送消息(没有发送成功的话,该函数会一直阻塞等)
  • IPC_NOWAIT:非阻塞方式发送消息,不管发送成功与否,函数都将返回

msgrcv()

#include 
#include 
#include 
//从消息队列中取出别人所放的某个编号的消息
 ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,\
                      int msgflg);
//返回值
		//成功:返回消息正文的字节数
		//失败:返回-1,errno被设置

五个参数:

  • msqid:消息队列的标识符
  • msgp:缓存地址,缓存用于存放所接收的消息
  • msgsz:消息正文的大小
  • msgtyp:你要接收消息的编号
  • msgflg:0:阻塞接收消息;IPC_NOWAIT:非阻塞接收消息

程序—消息队列的通信

#include 
#include 
#include 
#include 
#include 
#include 
#include 
 #include 
 #include 
#define MSG_FIFE "./msgque"
#define MSG_LENGTH 1024
//int msgget(key_t key, int msgflg);
//key_t ftok(const char *pathname, int proj_id);
void print_error(char* str){
    perror(str);
    exit(-1);
}
int create_or_get_MSG(void){
      int fd=0;
      int msgid=0;
      key_t key=0;
      //打开文件,没有就创建
      fd=open(MSG_FIFE,O_RDWR|O_CREAT,0664);
      if(fd==-1) print_error("open fails\n");
      //生成唯一key,用函数ftok()
      key=ftok(MSG_FIFE,'a');
      if(key==-1) print_error("generate key fails\n");
      //消息队列的获取或创建
      msgid=msgget(key,0664|IPC_CREAT);//别忘IPC_CREAT
      if(msgid==-1) print_error("msgget fails\n");
      return msgid;
}
struct msgbuf {//使用时候自己定义
        long mtype;       
        char mtext[MSG_LENGTH];   
};
int main(int argc,char** argv){
    if(argc!=2) print_error("input two args\n");
    int msgID=-1;
    msgID=create_or_get_MSG();
    long recv_type=0;
    recv_type=atol(argv[1]);
    pid_t ret=fork();
    if(ret>0){//父进程
    //int msgsnd(int msqid, const void *msgp,\
                     size_t msgsz, int msgflg);
        struct msgbuf msg_buf={0};
        while(1){
           bzero(&msg_buf,sizeof(msg_buf));
           /*封装消息包*/
           printf("输入要通信的内容:\n");
           //scanf("%s",msg_buf.mtext);
           read(0,msg_buf.mtext,sizeof(msg_buf.mtext));
           printf("输入要通信msgbuf的编号\n");
           //read(0,&msg_buf.mtype,sizeof(msg_buf.mtype));
           scanf("%ld",&msg_buf.mtype);
           msgsnd(msgID,&msg_buf,MSG_LENGTH,0);
        }
    }
    //ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,\
                      int msgflg);
    else if(ret==0){//子进程
           struct msgbuf msg_buf={0}; 
          /*接收消息*/
          while(1){
            int mm=0;
            bzero(&msg_buf,sizeof(msg_buf));
            mm=msgrcv(msgID,&msg_buf,MSG_LENGTH,recv_type,0);
            if(mm>0)
                printf("%s\n",msg_buf.mtext);
          }
    }
    return 0;
}

System V IPC+消息队列_第3张图片

进程结束,自动删除消息队列

msgctl()
 #include 
 #include 
 #include 
//功能是根据cmd指定的要求,去控制消息队列
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
进行哪些控制
  • 获取消息队列的属性信息
  • 修改消息队列的属性信息
  • 删除消息队列

调用msgctl函数的最常见目的就是删除消息队列

参数
  • msqid:消息队列标识符

  • cmd:控制选项

    其实cmd有很多选项,我这里只简单介绍三个

    • IPC_STAT:获取属性信息

      把msqid消息队列的属性信息读到第三个参数指定的缓存

    • IPC_SET:使用第三个参数中的新设置去修改消息队列的属性IPC_SET

    • 定义一个struct msqid_ds buf
    • 将新的属性信息设置到buf中
    • msgctl函数就会使用buf中的新属性去修改消息队列原有的属性
    • IPC_RMID:删除消息队列
  • ​ buf:存放属性信息(了解)

struct msqid_ds {
		struct ipc_perm  msg_perm; /* 消息队列的读写权限和所有者 */
		time_t  msg_stime;    /* 最后一次向队列发送消息的时间*/
		time_t  msg_rtime;    /* 最后一次从消息队列接收消息的时间 */
		time_t  msg_ctime;    /* 消息队列属性最后一次被修改的时间 */
		unsigned  long __msg_cbytes; /* 队列中当前所有消息总的字节数 */
		msgqnum_t  msg_qnum;     /* 队列中当前消息的条数*/
		msglen_t msg_qbytes;  /* 队列中允许的最大的总的字节数 */
		pid_t  msg_lspid;     /* 最后一次向队列发送消息的进程PID */
		pid_t  msg_lrpid;     /* 最后一次从队列接受消息的进程PID */
		};
//struct ipc_perm  msg_perm; 
struct ipc_perm {
		key_t   __key;   /* Key supplied to msgget(2):消息队列的key值*/
        uid_t   uid;    /* UID of owner :当前这一刻正在使用消息队列的用户 */
		gid_t   gid;    /* GID of owner :正在使用的用户所在用户组 */
		uid_t   cuid;   /* UID of creator :创建消息队列的用户 */
		gid_t   cgid;   /* GID of creator :创建消息队列的用户所在用户组*/        unsigned short mode;    /* Permissions:读写权限(比如0664) */
 unsigned short __seq; /* Sequence number :序列号,保障消息队列ID不被立即 重复使用 */};
  • 控制1:获取消息队列属性

    struct msqid_ds buf;
    msgctl(msgid, IPC_STAT, &buf);

  • 控制2:删除消息队列

    msgctl(msgid, IPC_RMID, NULL);

利用信号捕获,删除消息队列

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MSG_FIFE "./msgque"
#define MSG_LENGTH 1024
int msgID=-1;//全局变量
//int msgget(key_t key, int msgflg);
//key_t ftok(const char *pathname, int proj_id);
void print_error(char* str){
    perror(str);
    exit(-1);
}
int create_or_get_MSG(void){
      int fd=0;
      int msgid=0;
      key_t key=0;
      //打开文件,没有就创建
      fd=open(MSG_FIFE,O_RDWR|O_CREAT,0664);
      if(fd==-1) print_error("open fails\n");
      //生成唯一key,用函数ftok()
      key=ftok(MSG_FIFE,'a');
      if(key==-1) print_error("generate key fails\n");
      //消息队列的获取或创建
      msgid=msgget(key,0664|IPC_CREAT);//别忘IPC_CREAT
      if(msgid==-1) print_error("msgget fails\n");
      return msgid;
}
struct msgbuf {//使用时候自己定义
        long mtype;       
        char mtext[MSG_LENGTH];   
};
void signal_fun(int signo){
    msgctl(msgID,IPC_RMID,NULL);
    exit(-1);
}
int main(int argc,char** argv){
    if(argc!=2) print_error("input two args\n");
    msgID=create_or_get_MSG();
    long recv_type=0;
    recv_type=atol(argv[1]);
    pid_t ret=fork();
    if(ret>0){//父进程
    //int msgsnd(int msqid, const void *msgp,\
                     size_t msgsz, int msgflg);
        signal(SIGINT,signal_fun);            
        struct msgbuf msg_buf={0};
        while(1){
           bzero(&msg_buf,sizeof(msg_buf));
           /*封装消息包*/
           printf("输入要通信的内容:\n");
           //scanf("%s",msg_buf.mtext);
           read(0,msg_buf.mtext,sizeof(msg_buf.mtext));
           printf("输入要通信msgbuf的编号\n");
           //read(0,&msg_buf.mtype,sizeof(msg_buf.mtype));
           scanf("%ld",&msg_buf.mtype);
           msgsnd(msgID,&msg_buf,MSG_LENGTH,0);
        }
    }
    //ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,\
                      int msgflg);
    else if(ret==0){//子进程
           struct msgbuf msg_buf={0}; 
          /*接收消息*/
          while(1){
            int mm=0;
            bzero(&msg_buf,sizeof(msg_buf));
            mm=msgrcv(msgID,&msg_buf,MSG_LENGTH,recv_type,0);
            if(mm>0)
                printf("%s\n",msg_buf.mtext);
          }
    }
    return 0;
}
  • 当你的程序必须涉及到多进程网状交叉通信时,消息队列是上上之选
  • 消息队列的缺点,不能实现大规模数据的通信
  • 大规模数据的通信,必须使用后面讲的“共享内存”来实现

你可能感兴趣的:(LINUX系统编程,unix,linux,服务器,系统编程)