linux两个进程通过消息队列互发信息

robotke

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

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

struct my_msg_st
{
    long int my_msg_type;
        unsigned char msg_data_buf[36];
};

int main(void)
{
        int i;
        int running=1;
        int rtn_rcv;
        int msg_rcv_id;
        int msg_snd_id;
        key_t msg_snd_key;
        key_t msg_rcv_key;
        struct my_msg_st data_msg1;
        long int msg_to_receive=0;
        msg_snd_key = ftok("/tmp/TTMS/GM", 'b');
        msg_rcv_key = ftok("/tmp/TTMS/GM", 'a');

        /*创建消息队列*/
        msg_rcv_id=msgget(msg_rcv_key,0666 | IPC_CREAT);
        msg_snd_id=msgget(msg_snd_key,0666 | IPC_CREAT);
       
        if(msg_rcv_id==-1)
        {
            fprintf(stderr,"msgget failed with error: %d\n",errno);
                exit(EXIT_FAILURE);
        }
        printf("the message1 rcv id:%d\n", msg_rcv_id);
       
                if(msg_snd_id==-1)
        {
            fprintf(stderr,"msgget failed with error: %d\n",errno);
                exit(EXIT_FAILURE);
        }
        printf("the message1 snd id:%d\n", msg_snd_id);
        for (i=0; i<36; i++)
        {
                        data_msg1.msg_data_buf[i] = 36 + i;       
        }
        data_msg1.my_msg_type = getpid();

        /*循环从消息队列中接收消息*/
        while(running)
        {
                if(msgsnd(msg_snd_id,&data_msg1,36,0)==-1)
                {
                    fprintf(stderr,"msgsed failed\n");
                        exit(EXIT_FAILURE);
                }
                /*读取消息*/
            if((rtn_rcv = msgrcv(msg_rcv_id,&data_msg1,36,msg_to_receive,0))==-1)
                {
                    fprintf(stderr,"msgrcv failed with error: %d\n",errno);
                        exit(EXIT_FAILURE);
                }
                for (i=0; i<rtn_rcv; i++)
                {
                        printf("rcv data size:%d\n", rtn_rcv);
                        printf(">>>%d>>>",data_msg1.msg_data_buf[i]);
                }
                /* 重新进行赋值 */
                for (i=0; i<36; i++)
                {
                                data_msg1.msg_data_buf[i] = i;       
                }
                sleep(3);
        }
}
这里明明创建了两个消息队列，为何打印出来的消息队列的ID值确实一样的。
        msg_rcv_id=msgget(msg_rcv_key,0666 | IPC_CREAT);
        msg_snd_id=msgget(msg_snd_key,0666 | IPC_CREAT);
这个程序想在一个进程中创建两个消息队列，一个用来发送消息给另一个进程，一个队列用来接受另一个进程的消息。
可是这里怎么创建了以后只是一个消息了呢？导致自己发送了信息，自己接受了信息？？？？？为什么啊？？？

lidech

楼主请仔细看看这两句：

        msg_snd_key = ftok("/tmp/TTMS/GM", 'b');
        msg_rcv_key = ftok("/tmp/TTMS/GM", 'a');

函数ftok()的参数，UNP2中有讲其原理

whutchao

/*
本程序主要功能是实现两个进程间的通过信息队列来传输数据

*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>



struct msgbuf
{
        long mtype;       /* message type, must be > 0 */
       char mtext[255];    /* message data */
} ;


int main()
{
       
        pid_t pid ;

        key_t key ;
        int messageID ;   //消息队列符号
        struct msgbuf sndmsg ;  
        struct msgbuf rcvmsg ;        


        key = ftok("." ,1) ;
        messageID = msgget(key ,IPC_CREAT | 0666) ;  //获取消息队列的ID
        memset(&sndmsg ,0 ,sizeof(struct msgbuf)) ;  //清空

        sndmsg.mtype = getpid() ;   //将父进程的ID赋给消息类型
        strcpy(sndmsg.mtext ,"hello test data ") ;
        pid = fork() ;  //创建一个子进程
       
        if(pid == 0 )
        {
                //子进程
                //从消息队列中接收消息,如果消息队列为空，则返回打印相关信息，否则打印接收到的消息
                printf("%d子进程\n" ,getpid() ) ;

                if(rcvmsg.mtext == " ")
                {
                        printf("消息队列为空，没有消息\n") ;
                }
                else
                {
                        //清空rcvmsg
                        memset(&rcvmsg ,0 ,sizeof(struct msgbuf))  ;
                        if(msgrcv(messageID ,&rcvmsg ,sizeof(struct msgbuf) ,sndmsg.mtype ,IPC_NOWAIT) == -1 )
                        {
                                fprintf(stderr ,"msgrcv errno :%d\n",errno) ;
                        }
                        else
                        {
                                printf("接收到的消息是：%s\n" ,rcvmsg.mtext) ;
                        }
                }
        }
        else
        {
                //父进程  
                //把消息发送到消息队列中去
                printf("%d父进程\n" ,getpid() ) ;


                if(msgsnd(messageID ,&sndmsg ,sizeof(struct msgbuf) ,IPC_NOWAIT )  == -1)
                {
                        fprintf(stderr ,"msgsnd errno :%d",errno) ;
                }
                else
                {
                        printf("发送成功\n") ;
                }
               
        }

        return 0 ;
}