进程间通信_消息队列与共享内存与信号量

最新推荐文章于 2023-04-11 17:38:40 发布

hhzxzy

最新推荐文章于 2023-04-11 17:38:40 发布

阅读量178

点赞数 1

分类专栏：进程与线程

本文链接：https://blog.csdn.net/qq_42948022/article/details/102557823

版权

进程与线程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

三种系统V IPC

消息队列：
	消息队列是消息的链接表 ,存放在内核中并由消息队列标识符标识。
消息队列：
	同一块物理内存被映射到进程A、B各自的进程地址空间。
	进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。
	由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。
信号量：
	可以被多个进程共享的变量。（信号是cpu发给所以进程的通知，进程是否接受，是否处理要看进程本身）

消息队列：
key = ftok("./7-1",'b');
msgid = msgget(key, IPC_CREAT | 0666);
len = msgsnd(msgid,(void *)&sndbuf,100,0);
rcvLen=msgrcv(msgid,(void *)&rcvbuf,100,1,0);

共享内存：
key=ftok("write.c",0x00);
shmid=shmget(key,512,IPC_CREAT|0600 ) ;
shmaddr=(book *)shmat(shmid,NULL,0);
shmdt(shmaddr);		//断开映射

信号量：
key= ftok("mysem",'s');
sem_id= semget(key,2,IPC_CREAT|0644);
ret= semctl(sem_id,0,SETALL,arg);
semop(sem_id,(struct sembuf*)&sops[1],1);
semctl(sem_id,0,IPC_RMID);

进程间通信----消息队列

write.c
#include <stdio.h>
#include <sys/msg.h>
#include <string.h>
   
typedef struct msgque
{
    long type;          //long型的type标识
    char content[100];
}mq;

int main()
{
    int key;
    int msgid;
    mq  sndbuf;
    int rcvLen;
    int flag=1;
    key = ftok("./7-1",'b');
    msgid = msgget(key, IPC_CREAT | 0666);  //建消息队列
    if(msgid==-1)
            printf("error\n");

    while(1)
    {
        printf("send输入: ");
        fgets(sndbuf.content,100, stdin);
        if(strncmp(sndbuf.content,"end",3)==0)
            flag=0;
        sndbuf.type = 1;
        msgsnd(msgid,(void *)&sndbuf,100,0);//发送给消息队列
        sleep(1);
        if(flag==0)
            return 0;
    }   
    return 0;
}

#include <stdio.h>
#include <sys/msg.h>
#include <string.h>
   
typedef struct msgque
{
    long type;          //long型的type标识
    char content[100];
}mq;

int main()
{
    int key;
    int msgid;
    mq  rcvbuf;
    int rcvLen;
    key = ftok("./7-1",'b');
    msgid = msgget(key, IPC_CREAT | 0666);  //建消息队列
    if(msgid==-1)
            printf("error\n");

    while(1)
    {
        rcvLen=msgrcv(msgid,(void *)&rcvbuf,100,1,0);
        if(strncmp(rcvbuf.content,"end",3)!=0)
        {
            printf("receive接受：%s",rcvbuf.content);
        }
        else
        {
            printf("结束\n");
            return 0;
        }
    }
    return 0;
 }

进程间通信----共享内存

write.c
/*共享内存实现进程通信
    key=ftok("write.c",0x00);   //两个非亲缘进程用同一个key
    int shmid = shmget(key, 512, IPC_CREAT|0600);ipc_private(亲缘间代替key)
    char *shmaddr;
    写端：shmaddr = (char *)shmat(shmid,NULL,0); 
            //id与内存绑定，然后写shmaddr
         shmdt(shmaddr);    //关闭后让读端读
    读端：shmaddr=(char *)shmat(shmid,NULL,0);
*/
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<error.h>
#include<string.h>
#include<sys/types.h>
typedef struct book
{
    char no[8];
    char name[8];
    double price;
}book;


int main(void)
{
    int shmid;
    key_t key;
    book *shmaddr;
    book allbook [2]={  {"001","math",12.5},
                   {"002","math",13.5}
             };

    key=ftok("write.c",0x00);           //建shm
    if(key==-1){
        perror("key error\n");
        return -1;
    }
    printf("key=%d\n",key);
    shmid=shmget(key,512,IPC_CREAT|0600 ) ;
    if (shmid<0){
        perror("shmid get error\n") ;
        return -1 ;
    }

    printf("shmid =%d\n",shmid);                //连shm
    shmaddr=(book *)shmat(shmid,NULL,0);
    if(shmaddr<(book *)0){
        perror("shmat addr error\n");
        return -1;
    }

    memcpy(shmaddr,allbook,sizeof(book)*2);

    int i;
    for(i=0;i<2;i++)
    {
        printf("no:%s,",(*(shmaddr+i)).no);
        printf("name:%s,",shmaddr[i].name);
        printf("price:%lf\n",shmaddr[i].price);        
    }
    shmdt(shmaddr);
    return 0 ;
} 

read.c
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<error.h>
#include<string.h>
#include<sys/types.h>
typedef struct book
{
    char no[8];
    char name[8];
    double price;
}book;


int main(void)
{
    int shmid,i;
    key_t key;
    book *shmaddr;

    key=ftok("write.c",0x00);           //建shm
    if(key==-1){
        perror("key error\n");
        return -1;
    }
    printf("key=%d\n",key);
    shmid=shmget(key,512,IPC_CREAT|0600 ) ;
    if (shmid<0){
        perror("shmid get error\n") ;
        return -1 ;
    }

    printf("shmid =%d\n",shmid);                //连shm
    shmaddr=(book *)shmat(shmid,NULL,0);
    if(shmaddr<(book *)0){
        perror("shmat addr error\n");
        return -1;
    }

    for(i=0;i<2;i++)
    {
        printf("no:%s,",(*(shmaddr+i)).no);
        printf("name:%s,",shmaddr[i].name);
        printf("price:%lf\n",shmaddr[i].price);        
    }

    shmdt(shmaddr);
    return 0 ;
}

进程间通信----信号量

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

int sem_id;
void init()
{
    key_t key;
    int ret;
    unsigned short sem_array[2];
    union semun
    {
        int val;
        struct semid_ds *buf;
        unsigned short *array;
    }arg;
    key= ftok("mysem",'s');
    sem_id= semget(key,2,IPC_CREAT|0644);
    sem_array[0]= 0;
    sem_array[1]= 100;
    arg.array = sem_array;
    ret= semctl(sem_id,0,SETALL,arg);
    if(ret== -1)
    {
        printf("SETALL failed (%d)\n",errno);
    }
    printf("productor init is %d\n",semctl(sem_id,0,GETVAL));//getval
    printf("space init is %d\n\n",semctl(sem_id,1,GETVAL));
}

void del()
{
    semctl(sem_id,0,IPC_RMID);
}

int main(int argc,char *argv[])
{
    struct sembuf sops[2];
    sops[0].sem_num= 0;
    sops[0].sem_op= 1;
    sops[0].sem_flg= 0;

    sops[1].sem_num= 1;
    sops[1].sem_op= -1;
    sops[1].sem_flg= 0;
    init();
    printf("以下为生产者\n");
    while(1)
    {
        printf("\n输出前：\n");
        printf("productor number is %d\n",semctl(sem_id,0,GETVAL));
        printf("space number is %d\n",semctl(sem_id,1,GETVAL));
        semop(sem_id,(struct sembuf*)&sops[1],1);
        printf("now producing...\n");
        semop(sem_id,(struct sembuf*)&sops[0],1);
        printf("\nafter produce\n");
        printf("space number is %d\n",semctl(sem_id,1,GETVAL));
        printf("productor number is %d\n",semctl(sem_id,0,GETVAL));
        sleep(2);
    }
    del();
    return 0;
}


//sem_customer.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>

int sem_id;
void init()
{
    key_t key;
    key=ftok("mysem",'s');
    sem_id= semget(key,2,IPC_CREAT|0644);
}

int main(int argc,char *argv[])
{
    struct sembuf sops[2];
    sops[0].sem_num= 0;
    sops[0].sem_op= -1;
    sops[0].sem_flg= 0;

    sops[1].sem_num= 1;
    sops[1].sem_op= 1;
    sops[1].sem_flg= 0;
    init();
    printf("this is customer\n");
    while(1)
    {
        printf("\n\nbefore consume:\n");
        int ret= semctl(sem_id,0,GETVAL);
        int ret1= semctl(sem_id,1,GETVAL);
        printf("productor is %d\n",ret);
        printf("space is %d\n",ret1);
        semop(sem_id,(struct sembuf*)&sops[0],1);
        printf("now consuming...\n");
        semop(sem_id,(struct sembuf*)&sops[1],1);
        printf("\nafter consume\n");
        printf("productor number is %d\n",semctl(sem_id,0,GETVAL));
        printf("space number is %d\n",semctl(sem_id,1,GETVAL));
        sleep(3);
    }
    return 0;
}

hhzxzy

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
进程间通信_消息队列与共享内存与信号量

三种系统V IPC消息队列：消息队列是消息的链接表 ,存放在内核中并由消息队列标识符标识。消息队列：同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。信号量：可以被多个进程共享的变量。（信号是cpu发给所以进程的通知，进程是否接受，是否处...
复制链接

扫一扫