精华内容
下载资源
问答
  • Linux消息队列整理

    2015-12-29 11:46:57
    Linux消息队列整理

    消息队列和有名管道一样,都是文件,因此为获取消息队列的键值,我们可以通过ftok(函数)将文件转化为键值

    #include<sys/types.h>

    #include<sys/ipc.h>

    key_t ftok(char*pathname, int id)

    功能:返回文件名对应的键值

    pathname:文件名(含路径)

    id:项目名(不为0即可)


    10.1打开/创建消息队列

    10.1.1 函数名

    msgget

    10.1.2 函数原形

    int msgget(key_t key,int msgflg) 

    10.1.3 函数功能

    获取/创建一个消息队列标识符

    10.1.4 所属头文件

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

    10.1.5 返回值

    成功:返回消息队列标识符  失败:返回-1

    10.1.6 参数说明

    key:与消息文件对应的键值,由ftok获取

    msgflg:标志位

        IPC_CREAT:创建新的消息队列

        IPC_EXCL:与IPC_CREAT一同使用,表示如果要创建的消息队列已经存在,则返回错误

        IPC_NOWAIT:读写消息队列要求无法得到满足,不阻塞

    在以下两种情况下,将创建一个新的消息队列

      1.如果没有与键值key相对应的消息队列,并且msgflg中包含了IPC_CREAT标志位。

      2.key参数为IPC_PRIVATE

     

    创建消息队列

    int open_queue(key_t keyval)

    {

        intqid;

    if((qid=mesget(keyval,IPC_CREATE))==-1)

        return(-1);

    return (qid); 

    }

     

    10.2向消息队列发送消息(操作消息队列)

    10.2.1 函数名

    msgsnd

    10.2.2 函数原形

    int msgsnd(int msqid,struct msgbuf*msgp,size_t msgsz,int msgflg)

    10.2.3 函数功能

    向消息队列中发送一条消息

    10.2.4 所属头文件

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

    10.2.5 返回值

    成功:返回0  失败:返回-1

    10.2.6 参数说明

    msqid:已打开的消息队列id

    msgp:存放消息的结构

    struct msgbuf

    {

        long mtype;//消息类型>0

        char mtext[1];/*消息数据的首地址*/

     }

    msgsz:消息数据长度

    msgflg:发送标志,有意义的msgflg标志为IPC_NOWAIT,指明在消息队列没有足够空间容纳要发送的消息时,msgsnd是否等待


    10.3从消息队列中取消息

    10.3.1 函数名

    msgrcv

    10.3.2 函数原形

    int msgrcv(int msqid,structmsgbuf *msgp,size_t msgsz,long  msgtyp,

    int msgflg)

    10.3.3 函数功能

    从msqid代表的消息队列中读取一个msgtyp类型的消息,并把消息存储在msgp指向的msgbuf结构中。在成功地读取了一条消息以后,队列中的这条消息将被删除

    10.3.4 所属头文件

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

    10.3.5 返回值

    成功:返回0  失败:返回-1

    10.3.6 参数说明

    msqid:待取消息队列中消息的id

    msgp:存放消息的结构

    struct msgbuf{ long mtype;//消息类型>0

                    char mtext[1];/*消息数据的首地址*/  }

    msgsz:消息数据长度

    msgtyp:待取消息的类型,与发送消息的的结构体成员msgbuf.mtype相对应,消息队列中可以有不同的消息,通过该参数来确定收哪种消息;一个类型可以存取多条消息,按先进先出的规则,从消息队列中取出该消息

    msgflg:接收标志,通常为:IPC_NOWAIT

    接收消息代码(demo)

    int read_message(int qid,long type,structmymsgbuf*qbuf)

        intresult,length;

    length=sizeof(struct mymsgbuf)-sizeof(long);//消息的长度

    //等价于length = sizeof(mymsgbuf.data);

    if((result=msgrcv(qid,qbuf,length,type,0))==-1)

      return(-1);

    return(result);


    10.4综合代码
    #include<sys/types.h>
    #include<sys/ipc.h>
    #include<sys/msg.h>
    #include<unistd.h>
    
    struct msg_buf
    {
       int mtype;
       char data[255];
    };
    
    int main()
    {
       key_t key;
       int msgid;
       int ret;
       struct msg_buf msgbuf;
       
       key = ftok("/tem",'a');
       printf("key = [%x]\n",key);
       msgid = msgget(key,IPC_CREAT|0666);/*通过文件对应*/	
       
       if (msgid == -1)
       {
          printf("creat error\n");
          return -1;	
       }
       
       msgbuf.mtype = getpid();//getpid()获取当前进程的PID,并将该值赋给mtype
       strcpy(msgbuf.data,"test haha");
       ret = msgsnd(msgid, &msgbuf, sizeof(msgbuf.data), IPC_NOWAIT);
       if(ret == -1)
       {
          printf("send message error\n");
          return -1;	
       }
       
       memset(&msgbuf,0,sizeof(msgbuf));
       ret = msgrcv(msgid, &msgbuf, sizeof(msgbuf.data), getpid(), IPC_NOWAIT);
       if(ret == -1)
       {
         printf("receive message error\n");
         return -1;	
       }
       printf("recv msg = [%s]\n",msgbuf.data);
       printf("recv msg = %s\n",msgbuf.data);
       
    }
    运行结果:



     


    展开全文
  • Linux消息队列

    2017-02-04 21:37:39
    ·消息队列就是消息的链表,它允许一个或多个进程向它写消息,一个进程或多个进程从中读消息。具有一定的FIFO的特性,但是可实现消息的随即查询。这些消息存在于内核中,由“队列ID”来标识。 消息队列使用场景: ·...

    消息队列:

    ·消息队列就是消息的链表,它允许一个或多个进程向它写消息,一个进程或多个进程从中读消息。具有一定的FIFO的特性,但是可实现消息的随即查询。这些消息存在于内核中,由“队列ID”来标识。

    消息队列使用场景

    ·消息队列的主要特点是异步处理,目的是减少请求响应时间和解耦。通常使用在比较耗时而且不需要即时(同步)返回结果的操作作为消息放入消息队列。

    ·由于使用了消息队列,只要保证消息格式不变,消息的发送方和接受方并不需要彼此联系,也不需要受对方的影响,即解耦和。

    使用场景的话,举个例子:
    假设用户在你的软件中注册,服务端收到用户的注册请求后,它会做这些操作:
    1. 校验用户名等信息,如果没问题会在数据库中添加一个用户记录
    2. 如果是用邮箱注册会给你发送一封注册成功的邮件,手机注册则会发送一条短信
    3. 分析用户的个人信息,以便将来向他推荐一些志同道合的人,或向那些人推荐他
    4. 发送给用户一个包含操作指南的系统通知
    5. 等等……
    但是对于用户来说,注册功能实际只需要第一步,只要服务端将他的账户信息存到数据库中他便可以登录上去做他想做的事情了。至于其他的事情,非要在这一次请求中全部完成么?值得用户浪费时间等你处理这些对他来说无关紧要的事情么?所以实际当第一步做完后,服务端就可以把其他的操作放入对应的消息队列中然后马上返回用户结果,由消息队列异步的进行这些操作。

    或者还有一种情况,同时有大量用户注册你的软件,再高并发情况下注册请求开始出现一些问题,例如邮件接口承受不住,或是分析信息时的大量计算使cpu满载,这将会出现虽然用户数据记录很快的添加到数据库中了,但是却卡在发邮件或分析信息时的情况,导致请求的响应时间大幅增长,甚至出现超时,这就有点不划算了。面对这种情况一般也是将这些操作放入消息队列(生产者消费者模型),消息队列慢慢的进行处理,同时可以很快的完成注册请求,不会影响用户使用其他功能。

    所以在软件的正常功能开发中,并不需要去刻意的寻找消息队列的使用场景,而是当出现性能瓶颈时,去查看业务逻辑是否存在可以异步处理的耗时操作,如果存在的话便可以引入消息队列来解决。否则盲目的使用消息队列可能会增加维护和开发的成本却无法得到可观的性能提升,那就得不偿失了。


    (来自知乎一个前辈的回答,

    作者:ScienJus
    链接:https://www.zhihu.com/question/34243607/answer/58314162)

    Linux下消息队列

    ·消息队列的实现包括创建和打开队列、添加消息、读取消息和控制消息队列这四种操作。

    linux下用四个函数实现:


    ·msgget:创建和打开队列,其消息数量受系统限制。

     所需头文件:#include <sys/types.h>

                          #include <sys/ipc.h>

                          #include <sys/shm.h>

     函数原型:int msgget(key_t key, int flag)

     函数传入值:Key:返回新的或已有队列ID,函数将它与已有的消息队
    列对象的关键字进行比较来判断消息队列对象是否已经创建。 

                          Flag:消息队列的建立标志和存取权限

                          可以取以下值:

                           IPC_CREAT:创建新的消息队列

                           IPC_EXCL与IPC_CREAT:一同使用,表示如果要创建的消息队列已经存在,则返回错误。

                           IPC_NOWAIT:读写消息队列要求无法满足时,不阻塞。

     函数返回值:成功:消息队列ID

                           出错:-1


    ·msgsnd:添加消息,将消息添加到消息队列尾部

    所需头文件:#include <sys/types.h>

                          #include <sys/ipc.h>

                          #include <sys/shm.h>

     函数原型:int msgsnd(int msqid,const void *prt,size_t size,int flag)

     函数传入值:

                          msqid:消息队列的id

                           prt:指向消息结构的指针,该消息结构msgbuf为:

                           struct msgbuf{

                           long mtype;//消息类型

                           char mtext[1];//消息正文}

                           size:消息的字节数,不要以null结尾

                           flag:IPC_NOWAIT若消息并没有立即发送而调用进程会立即返回

                                     0:msgsnd调用阻塞直到条件满足为止                      

     函数返回值:成功:0

                           出错:-1

    ·msgrcv:读取消息,从消息队列中取走消息

    所需头文件:#include <sys/types.h>

                          #include <sys/ipc.h>

                          #include <sys/shm.h>

     函数原型:int msgsnd(int msqid, struct msgbuf *msgp, int size, long msgtype, int flag)

     函数传入值:

                          msqid:消息队列的id

                          msgp:消息缓冲区

                          size:消息的字节数,不要以null结尾

                          msgptype:0:接收队列中第一个消息

                                          大于0:接收消息队列中第一个类型为msgtyp的消息

                                          小于0:接收消息队列中第一个类型值不小于msgtyp绝对值且类型值又最小的消息

                          flag:MSG_NOERROR:若返回的消息比size字节多,则消息就会截短到size字节,且不通知消息发送                                                                  进程

                                    IPC_NOWAIT:若消息并没有立即发送调用进程会立即返回

                                    0:msgsnd调用阻塞直到条件满足为止                      

     函数返回值:成功:0

                           出错:-1

    ·msgctl:控制消息队列

    所需头文件:#include <sys/types.h>

                          #include <sys/ipc.h>

                          #include <sys/shm.h>

     函数原型:int msgctl(int msqid, int cmd, nt size, long msgtype, int flag)

     函数传入值:

                          msqid:消息队列的id

                          cmd:IPC_STAT:读取消息队列的数据结构msqid_ds,并将其存在buf指定的地址中

                                  IPC_SET: 设置消息队列的数据结构msqid_ds中的ipc_perm元素的值,这个值取自buf参数

                                  IPC_RMID:从系统内核中移走消息队列

                         Buf:消息队列缓冲区

     函数返回值:成功:0

                           出错:-1


    向消息队列添加消息:

    /**
    ipc_test_send.c
    author:huangpingyi
    date:2017/2/2
    **/
    
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    
    
    #define MAX_TEXT 512 //缓冲区大小
    
    struct my_msg_st {
         long int my_msg_type;
         char some_text[MAX_TEXT];
    };
    
    int main()
    {
    
       int running = 1;
       struct my_msg_st some_data;
       int msgid;
       char buffer[BUFSIZ];
    
       printf("BUFSIZ=%d\n",BUFSIZ);
       msgid = msgget((key_t)1234,0666 |IPC_CREAT);
       if(msgid == -1){
       printf(stderr, "msgget failed with error: %d\n", errno);
       exit(1);
    }
    while (running){
        printf("Enter some text:");
        fgets(buffer,BUFSIZ,stdin);
        some_data.my_msg_type = 1;//初始化消息类型
        strcpy(some_data.some_text,buffer);//初始化消息内容
    //添加消息到消息队列
        if(msgsnd(msgid,(void *)&some_data,MAX_TEXT,0)== -1){
           fprintf(stderr,"msgsnd faoled\n");
           exit(1);
    }
    if(strncmp(buffer, "end",3) == 0){
      running = 0;
    }
    }
    return 0;
    }

    接收消息队列的消息:

    /**
    ipc_test_recv.c
    author:huangpingyi
    date:2017/2/2
    **/
    
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/msg.h>
    
    
    #define BUFSIZE 512 //缓冲区大小
    
    struct my_msg_st {
         long int my_msg_type;
         char some_text[BUFSIZE];
    };
    
    int main()
    {
    
       int running = 1;
       struct my_msg_st some_data;
       int msgid;
       long int msg_to_receive = 0;
    
       printf("BUFSIZ=%d\n",BUFSIZ);
       msgid = msgget((key_t)1234,0666 |IPC_CREAT);
       if(msgid == -1){
       fprintf(stderr, "msgget failed with error: %d\n", errno);
       exit(1);
    }
    while (running){
         //
         if(msgrcv(msgid,(void *)&some_data,BUFSIZE,msg_to_receive,0)==-1){
              fprintf(stderr,"msgrcv failed with error:%d\n",errno);
              exit(1);
          }
          printf("You  wrote : %s",some_data.some_text);
    }
    if(strncmp(some_data.some_text, "end",3) == 0){
      running = 0;
    }
    if(msgctl(msgid,IPC_RMID,0) == -1){
       fprintf(stderr,"msgct(IPC_RMID) failed\n");
       exit(1);
      }
    
    return 0;
    }


    用ipcs  -q查看:

    发送消息到消息队列:



    接收消息:


    发送和接收消息:



                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            

    展开全文
  • 本人初学ARM板开发,今天学习linux下的消息队列函数例子程序下载:1.key_tftok(char*pathname,charproj)返回文件名对应的键值(把消息队列当作文件处理)头文件:#include#includepathname:文件名proj:项目名(不为0...

    本人初学ARM板开发,今天学习linux下的消息队列函数

    例子程序下载:

    1.key_t ftok(char *pathname,char proj)

    返回文件名对应的键值(把消息队列当作文件处理)

    头文件:#include     #include 

    pathname:文件名

    proj:项目名(不为0即可)

    2.int msgget(key_t key,int msgflg)

    打开或创建消息队列

    头文件:#include     #include     #include 

    key:键值,由ftok获得

    msgflg:标志位(

    IPC_CREAT,如果不存在,创建新的消息队列

    IPC_EXCL,与IPC_CREAT一起使用,表示如果消息队列已存在,则返回错误

    IPC_NOWAIT,读写消息队列要求无法得到满足时,不阻塞)

    返回值:与键值key相对应的消息队列描述字,出错时返回-1

    **在以下两种情况下,将创建一个新的消息队列:

    a)如果没有与键值key相对应的消息队列,并且msgflg参数中包含了IPC_CREAT标志位

    b)key参数为IPC_PRIVATE

    3.int msgsnd(int msqid,struct msgbuf *msgp,int msgsz,int msgflg)

    向消息队列中发送一条消息

    头文件:#include     #include     #include 

    msqid:消息队列id(消息队列的描述字)

    msgp:存放消息的结构(格式为:

    struct msgbuf

    {

    int mtype; /*消息类型> 0*/

    char mtex[1]; /*消息数据,字符数组*/

    };

    )

    msgsz:消息数据长度

    msgflg:发送标志,有意义的msgflg标志为IPC_NOWAIT,指明消息队列中没有足够空间容纳要发送的消息时,msgsnd是否等待,0表示等待

    返回值:发生错误时返回-1

    4.int msgrcv(int msqid,struct msgbuf *msgp,int msgsz,long msgtyp,int msgflg)

    从消息队列msqid中读取一个msgtyp类型的消息,并把消息存储在msgp指向的msgbuf结构体中。(在成功读取后,队列中的这条消息将被删除)

    5.int msgctl (int msqid, int cmd, struct msqid_ds *buf)

    消息队列属性控制

    msqid:消息队列的标识符。

    cmd:执行的控制命令,即要执行的操作。(包括以下选项:

    IPC_STAT:读取消息队列属性。取得此队列的msqid_ds 结构,并将其存放在buf指向的结构中。

    IPC_SET :设置消息队列属性。

    IPC_RMID:删除消息队列。

    IPC_INFO:读取消息队列基本情况。此命令等同于 ipcs 命令。

    这 4 条命令(IPC_STAT、IPC_SET、IPC_INFO 和 IPC_RMID)也可用于信号量和共享存储。)

    buf:临时的 msqid_ds 结构体类型的变量。用于存储读取的消息队列属性或需要修改的消息队列属性。

    举例:msgctl(qid, IPC_RMID, NULL) //删除消息队列

    例子程序下载:

    展开全文
  • linux 消息队列

    2013-09-24 10:47:56
    顾名思义,消息队列就是一些消息的列表,用户可以在消息队列中添加消息和读取消息等。从这点上看,消息队列具有一定的FIFO特性,但是它可以实现消息的随机查询,比FIFO具有更大的优势。同时,这些消息又是存在于内核...

        顾名思义,消息队列就是一些消息的列表,用户可以在消息队列中添加消息和读取消息等。从这点上看,消息队列具有一定的FIFO特性,但是它可以实现消息的随机查询,比FIFO具有更大的优势。同时,这些消息又是存在于内核中的,由“队列ID”来标识。

        消息队列的实现包括创建或打开消息队列、添加消息、读取消息和控制消息队列4种操作,其中创建或打开消息队列使用的函数是msgget(),这里创建的消息队列的数量会受到系统消息队列数量的限制;添加消息使用的函数是msgsnd(),它把消息添加到已打开的消息队列末尾;读取消息使用的函数是msgrcv(),它把消息从消息队列中取走,与FIFO不同的是,这里可以取走指定的某一条消息;控制消息队列使用的函数是msgctl(),它可以完成多项功能。

        表1列举了msgget()函数的语法要点。

    表1 msgget()函数语法要点

    所需头文件 #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    函数原型 int msgget(key_t key, int msgflg)
    函数传入值 key:消息队列的键值,多个进程可以通过它访问同一个消息队列,其中有个特殊值IPC_PRIVATE,用于创建当前进程的私有消息队列
    msgflg:权限标志位
    函数返回值 成功:消息队列ID
    出错:-1

        表2列举了msgsnd()函数的语法要点。

    表2 msgsnd()函数语法要点

    所需头文件 #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    函数原型 int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)
    函数传入值 msqid:消息队列的队列ID
    msgp:指向消息结构的指针,该消息结构msgbuf通常如下。
    struct msgbuf
    {
      long mtype; /* 消息类型,该结构必须从这个域开始 */
      char mtext[1]; /* 消息正文 */
    }
    msgsz:消息正文的字节数(不包括消息类型指针变量)
    msgflg IPC_NOWAIT:若消息无法立即发送(如当前消息队列已满),函数会立即返回
    0:msgsnd调用阻塞直到发送成功为止
    函数返回值 成功:0
    出错:-1

        表3列举了msgrcv()函数的语法要点。

    表3 msgrcv()函数语法要点

    所需头文件 #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    函数原型 int msgrcv(int msgid, void *msgp, size_t msgsz, long int msgtyp, int msgflg)
    函数传入值 msqid:消息队列的队列ID
    msgp:消息缓冲区,同msgsnd()函数的msgp
    msgsz:消息正文的字节数(不包括消息类型指针变量)
    msgtyp 0:接收消息队列中第一个消息
    大于0:接收消息队列中第一个类型为msgtyp的消息
    函数传入值 小于0:接收消息队列中第一个类型值不小于msgtyp绝对值且类型值最小的消息
    msgflg MSG_NOERROR:若返回的消息比msgsz字节多,则消息就会截短到msgsz字节,且不通知消息发送进程
    IPC_NOWAIT:若在消息队列中并没有相应类型的消息可以接收,则函数立即返回
    0:msgsnd()调用阻塞直到接收一条相应类型的消息为止
    函数返回值 成功:0
    出错:-1

        表4列举了msgctl()函数的语法要点。

    表4 msgctl()函数语法要点

    所需头文件 #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>
    函数原型 int msgctl (int msgqid, int cmd, struct msqid_ds *buf )
    函数传入值 msqid:消息队列的队列ID
    cmd:命令参数 IPC_STAT:读取消息队列的数据结构msqid_ds,并将其存储在buf指定的地址中
    IPC_SET:设置消息队列的数据结构msqid_ds中的ipc_perm域(IPC操作权限描述结构)值,这个值取自buf参数
    IPC_RMID:从系统内核中删除消息队列
    buf:描述消息队列的msqid_ds结构类型变量
    函数返回值 成功:0
    出错:-1

        下面的实例体现了如何使用消息队列进行两个进程(发送端和接收端)之间的通信,包括消息队列的创建、消息发送与读取、消息队列的撤销和删除等多种操作。

        消息发送端进程和消息接收端进程间不需要额外实现进程间的同步。在该实例中,发送端发送的消息类型设置为该进程的进程号(可以取其他值),因此接收端根据消息类型来确定消息发送者的进程号。注意这里使用了fotk()函数,它可以根据不同的路径和关键字产生标准的key。消息队列发送端的代码如下:

        /* msgsnd.c */
        #include <sys/types.h>
        #include <sys/ipc.h>
        #include <sys/msg.h>
        #include <stdio.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <string.h>
        #define BUFFER_SIZE 512


        struct message
        {
            long msg_type;
            char msg_text[BUFFER_SIZE];
        };
        int main()
        {
            int qid;
            key_t key;
            struct message msg;

            /* 根据不同的路径和关键字产生标准的key */
            if ((key = ftok(".", 'a')) == -1)
            {
                perror("ftok");
                exit(1);
            }
            /* 创建消息队列 */
            if ((qid = msgget(key, IPC_CREAT|0666)) == -1)
            {
                perror("msgget");
                exit(1);
            }
            printf("Open queue %d\n",qid);
            while(1)
            {
                printf("Enter some message to the queue:");
                if ((fgets(msg.msg_text, BUFFER_SIZE, stdin)) == NULL)
                {
                    puts("no message");
                    exit(1);
                }

                msg.msg_type = getpid();
                /* 添加消息到消息队列 */
                if ((msgsnd(qid, &msg, strlen(msg.msg_text), 0)) < 0)
                {
                    perror("message posted");
                    exit(1);
                }
                if (strncmp(msg.msg_text, "quit", 4) == 0)
                {
                    break;
                }
            }
            exit(0);
        }

        消息队列接收端的代码如下:

        /* msgrcv.c */
        #include <sys/types.h>
        #include <sys/ipc.h>
        #include <sys/msg.h>
        #include <stdio.h>
        #include <stdlib.h>
        #include <unistd.h>
        #include <string.h>
        #define BUFFER_SIZE 512

        struct message
        {
            long msg_type;
            char msg_text[BUFFER_SIZE];
        };
        int main()
        {
            int qid;
            key_t key;
            struct message msg;

            /* 根据不同的路径和关键字产生标准的key */
            if ((key = ftok(".", 'a')) == -1)
            {
                perror("ftok");
                exit(1);
            }
            /* 创建消息队列 */
            if ((qid = msgget(key, IPC_CREAT|0666)) == -1)
            {
                perror("msgget");
                exit(1);
            }
            printf("Open queue %d\n", qid);
            do
            {
                /* 读取消息队列 */
                memset(msg.msg_text, 0, BUFFER_SIZE);
                if (msgrcv(qid, (void*)&msg, BUFFER_SIZE, 0, 0) < 0)
                {
                    perror("msgrcv");
                    exit(1);
                }
                printf("The message from process %d : %s", msg.msg_type, msg.msg_text);

            } while(strncmp(msg.msg_text, "quit", 4));
            /* 从系统内核中移走消息队列 */
            if ((msgctl(qid, IPC_RMID, NULL)) < 0)
            {
                perror("msgctl");
                exit(1);
            }
            exit(0);
        }

        以下是程序的运行结果,输入“quit”则两个进程都将结束。

        $ ./msgsnd
        Open queue 327680
        Enter some message to the queue:first message
        Enter some message to the queue:second message
        Enter some message to the queue:quit
        $ ./msgrcv
        Open queue 327680
        The message from process 6072 : first message
        The message from process 6072 : second message
        The message from process 6072 : quit

        本文选自华清远见嵌入式培训教材《从实践中学嵌入式Linux应用程序开发》

         更多嵌入式电子书阅读和下载进入华清远见电子书频道

    展开全文
  • Linux消息队列编程

    2020-04-29 17:15:19
    Linux消息队列编程   消息队列,Unix的通信机制之一,可以理解为是一个存放消息(数据)容器。将消息写入消息队列,然后再从消息队列中取消息,一般来说是先进先出的顺序。可以解决两个进程的读写速度不同(处理...
  • linux消息队列

    2016-03-14 19:35:40
    消息队列 linux
  • linux 消息队列实例 (转) 转自:linux 消息队列实例  前言:  消息队列就是一个消息的链表。可以把消息看作一个记录,具有特定的格式以及特定的优先级。对消息队列有写权限的进程可以向其中...
  • Linux消息队列讲解

    千次阅读 2018-04-10 21:11:42
    消息队列一、消息队列1. 消息队列消息的链表,存放在内存中,由内核维护2. 特点1)消息队列允许一个或多个进程向它写入或者读取消息,并且每条消息都有类型2)消息队列可以实现消息的随机查询,消息不一定要以...
  • linux 消息队列实例

    2016-05-13 19:57:14
    前言:  消息队列就是一个消息的...对消息队列有读权限的进程则可以从消息队列中读走消息 函数: 1.创建新消息队列或取得已存在消息队列 原型:int msgget(key_t key, int msgflg); 参数:  ke
  • 想要把msgrcv 包装成可以指定阻塞时间的函数,我是这样做的,不知是否可行,有没有设计不足。 ``` int my_msgrcv(int msgid,void * msg,int len,long msgtype,int sec) { struct sigaction saNew, saOld; ...
  • linux消息队列函数(转)转载自:...linux消息队列函数     ----------------------------------------------------- linux消息队列函数 -----------------------
  • linux 消息队列机制

    万次阅读 2017-04-20 11:48:25
    Linux进程通信 消息队列 2009-12-14 | 阅:682 转:44 | 分享     现在我们来讨论第三种也是最后一种System V IPV工具:消息队列。在许多方面看来,消息队列类似于有名管道,但是却没有与打开与关闭管道的复杂...
  • Linux消息队列编程(简单应用)

    万次阅读 多人点赞 2018-08-15 23:35:51
    消息队列,Unix的通信机制之一,可以理解为是一个存放消息(数据)容器。将消息写入消息队列,然后再从消息队列中取消息,一般来说是先进先出的顺序。可以解决两个进程的读写速度不同(处理数据速度不同),系统耦合...
  • 前言:  消息队列就是一个消息的...对消息队列有读权限的进程则可以从消息队列中读走消息 函数: 1.创建新消息队列或取得已存在消息队列 原型:int msgget(key_t key, int msgflg); 参数:  ke
  • 消息队列函数由msgget、msgctl、msgsnd、msgrcv四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。 1. msgget函数原型 msgget(得到消息队列标识符或创建一个消息队列对象) 所...
  • linux消息队列总结

    2017-06-13 17:02:00
    每种进程通信方式实现方式和功能不一样,带来适用的场景也有所不同,消息队列是链表队列,它通过内核提供一个struct msqid_ds *msgque[MSGMNI]向量维护内核的一个消息队列列表,因此linux系统支持的最大消息队...
  • LINUX消息队列总结

    2018-01-17 14:36:20
    消息队列消息的链接表,存放在内核中并有消息队列标识符标识。每个消息队列有一个称为 key的名称,如同用户文件描述符一样,每个Unix消息队列还有一个消息队列描述符。 消息的结构 每个消息包含一个正长整型字段,...
  • linux消息队列操作

    2018-05-01 14:59:19
    基本函数说明 int msgget (key_t __key, int ...int msgctl (int __msqid, int __cmd, struct msqid_ds *__buf),消息队列控制,如删除消息队列,获取消息队列的信息等; ssize_t msgrcv (int __msqid, void *__msg...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,374
精华内容 39,349
关键字:

linux消息队列阻塞

linux 订阅