[Linux C编程]进程间的通信（二）

进程间的通信

共享内存

是被多个进程共享的一部分物理内存.共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容.

共享内存实现分为两个步骤:

1、创建共享、打开共享内存，使用shmget函数

2、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数

3. 分离共享内存

4. 控制、删除共享内存

创建shmget：

函数的作用：在内核中创建共享内存

函数的原型：int shmget(key_t key,int size,int shmflag);

函数的参数：key:键值，IPC_PRIVATE：私有的键值

size:创建的内存大小

shmflag:类似open权限

返回值：成功共享的内存标识符，出错 -1

头文件：#include <sys/ipc.h>

#include <sys/shm.h>

映射shmat：

函数的作用：映射共享内存，映射到各自的内存空间；

函数的原型：void * shmat(int shmat,const void * shmaddr,int flag);

函数的参数：shmid：内存标识符

shmaddr：映射共享内存到本地进程的指定地址，如果为NULL则由内核自动

分配。

shmflag:SHM_RDONLY:共享内存只读;

0:共享内存可读写

分离shmdt：

函数的作用：撤销共享内存的映射

函数的原型：int shmdt(const void * shmaddr);

函数的参数：shmaddr：被映射的共享内存地址

返回值：成功：0 出错：-1

使用共享内存实现通信：

shm1.c:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "shm_com.h"

int main(void)
{
    int running=1;
void *shared_memory=(void *)0;
struct shared_use_st *shared_stuff;
int shmid;


/*创建共享内存*/
shmid=shmget((key_t)1234,sizeof(struct shared_use_st),0666|IPC_CREAT);
if(shmid==-1)
{
    fprintf(stderr,"shmget failed\n");
exit(EXIT_FAILURE);
}

/*映射共享内存*/
shared_memory=shmat(shmid,(void *)0,0);
if(shared_memory==(void *)-1)
{
    fprintf(stderr,"shmat failed\n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X\n",(int)shared_memory);

/*让结构体指针指向这块共享内存*/
shared_stuff=(struct shared_use_st *)shared_memory;

/*控制读写顺序*/
shared_stuff->written_by_you=0;

/*循环的从共享内存中读数据，直到读到“end”为止*/
while(running)
{
   if(shared_stuff->written_by_you)
   {
       printf("You wrote:%s",shared_stuff->some_text);
   sleep(1);  //读进程睡一秒，同时会导致写进程睡一秒，这样做到读了之后再写
   shared_stuff->written_by_you=0;
   if(strncmp(shared_stuff->some_text,"end",3)==0)
   {
       running=0; //结束循环
   }
   }
}

/*删除共享内存*/
if(shmdt(shared_memory)==-1)
{
    fprintf(stderr,"shmdt failed\n");
    exit(EXIT_FAILURE);
}
       exit(EXIT_SUCCESS);
}

shm2.c:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "shm_com.h"

int main(void)
{
    int running=1;
void *shared_memory=(void *)0;
struct shared_use_st *shared_stuff;
char buffer[BUFSIZ];
int shmid;

/*创建共享内存*/
shmid=shmget((key_t)1234,sizeof(struct shared_use_st),0666|IPC_CREAT);
if(shmid==-1)
{
    fprintf(stderr,"shmget failed\n");
exit(EXIT_FAILURE);
}

/*映射共享内存*/
shared_memory=shmat(shmid,(void *)0,0);
if(shared_memory==(void *)-1)
{
    fprintf(stderr,"shmat failed\n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X\n",(int)shared_memory);

/*让结构体指针指向这块共享内存*/
shared_stuff=(struct shared_use_st *)shared_memory;

/*循环的向共享内存中写数据，直到写入的为“end”为止*/
while(running)
{
    while(shared_stuff->written_by_you==1)
{
    sleep(1);//等到读进程读完之后再写
printf("waiting for client...\n");
}
printf("Ener some text:");
fgets(buffer,BUFSIZ,stdin);
strncpy(shared_stuff->some_text,buffer,TEXT_SZ);
shared_stuff->written_by_you=1;
if(strncmp(buffer,"end",3)==0)
{
    running=0;  //结束循环
}
}

/*删除共享内存*/
if(shmdt(shared_memory)==-1)
{
    fprintf(stderr,"shmdt failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

shm_com.h:

#define TEXT_SZ 2048

struct shared_use_st
{
    int written_by_you;
char some_text[TEXT_SZ];
};

拓展：使用父子进程实现共同通信。（后续博客会贴出）

消息队列：

消息队列就是一个消息的链表.可以把消息看作一个记录，具有特定的格式.进程可以向中按照一定的规则添加新消息;另一些进程则可以从消息队列中读走消息

·创建打开消息队列msgget()

·读数据从队列msgrcv()

·写数据到队列msgsnd()

·控制消息队列msgctl()

创建msgget：

函数的作用：创建消息队列

函数的原型：int msgget(key_t key,int msgflag);

函数的参数：key 键值：IPC_PRIVATE 设定一个数字，也可以用ftok获得

msgflag:权限

返回值：成功：消息队列ID

出错：-1

头文件：#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/shm.h>

key_t key;

key = ftok(“/home/pipe/magget.c”,11);

写数据msgsnd:

函数的作用：写数据到消息队列

函数的原型：int msgsnd(int msgid,const void * msggp,size_t msgsize,int msgflag);

函数的参数：msggp 消息结构

struct msgbuf

{

long msgtype; //消息类型

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

};

msgsize:消息的字节数

msgflag:IPC_NOWAIT：写不进消息直接返回

0：一直等待到能写进去消息为止

返回值：成功 0 出错：-1

读数据msgrcv：

函数的作用：读数据到消息队列

函数的原型：int magrcv(int msgid,void *msgp,size_t msgsz,long int msgtyp,int msgflg);

函数的参数：msgid:消息队列的队列ID;

msgp:消息缓冲区，同于msgsnd()函数的msgp;

msgsz:消息正文的字节数（不包括消息类型指针变量）

msgtyp：0：接收消息队列中的第一个消息

>0：接收消息队列中的第一个类型为msgtyp的消息

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

又最小的消息。

msgflg：MSG_NOERROR：若返回的消息比msgsz字节多，则消息就会截短到

msgsz字节，且不通知消息发送进程。

IPC_NOWAIT：若在消息队列中并没有相应类型的消息可以接收，则函数立即

返回。

0：msgsnd()调用阻塞直到接收一条相应类型的消息为止。

返回值：成功 0，出错 -1

头文件：#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/shm.h>

控制msgctl：

函数的作用：控制消息队列，可以删除消息队列

函数的原型：int msgctl(int msgid,int cmd,struct msgid _ds * buf);

函数的参数：msgid: 消息队列的队列ID

cmd:IPC_STAT:读取消息队列的结构，存储在buf中

IPC_SET:设置队列的权限

IPC_RMID:删除消息队列

返回值：成功 0；出错 -1

利用消息队列实现通信:

msg1.c:

#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;
char some_text[BUFSIZ];
};

int main(void)
{
    int running=1;
int msgid;
struct my_msg_st some_data;
long int msg_to_receive=0;

/*创建消息队列*/
msgid=msgget((key_t)1234,0666 | IPC_CREAT);
if(msgid==-1)
{
    fprintf(stderr,"msgget failed with error: %d\n",errno);
exit(EXIT_FAILURE);
}
/*循环从消息队列中接收消息*/
while(running)
{
/*读取消息*/
    if(msgrcv(msgid,(void *)&some_data,BUFSIZ,msg_to_receive,0)==-1)
{
    fprintf(stderr,"msgrcv failed with error: %d\n",errno);
exit(EXIT_FAILURE);
}

printf("You wrote: %s",some_data.some_text);

/*接收到的消息为“end”时结束循环*/
if(strncmp(some_data.some_text,"end",3)==0)
{
    running=0;
}
}

/*从系统内核中移走消息队列*/
if(msgctl(msgid,IPC_RMID,0)==-1)
{
    fprintf(stderr,"msgctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

msg2.c：

#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>
#define MAX_TEXT 512

struct my_msg_st
{
    long int my_msg_type;
char some_text[MAX_TEXT];
};

int main(void)
{
    int running=1;
struct my_msg_st some_data;
int msgid;
char buffer[BUFSIZ];

/*创建消息队列*/
msgid=msgget((key_t)1234,0666 | IPC_CREAT);
if(msgid==-1)
{
    fprintf(stderr,"msgget failed with error:%d\n",errno);
exit(EXIT_FAILURE);
    }

/*循环向消息队列中添加消息*/
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,"msgsed failed\n");
exit(EXIT_FAILURE);
}

/*用户输入的为“end”时结束循环*/
if(strncmp(buffer,"end",3)==0)
{
    running=0;
}
}
exit(EXIT_SUCCESS);
}

信号量：

·信号量(又名：信号灯)与其他进程间通信方式不大相同，主要用途是保护临界资源.

·进程可以根据它判定是否能够访问某些共享资源。除了用于访问控制外，还可用于进程同步

1.创建打开信号量，semget()

2.初始化信号量，semctl()的SETVAL操作。当使用二维信号量时将信号量初始化为1；

3. 进行信号量的PV操作，调用semop()函数。

4.如果不用信号量，从系统中删除他/她，使用semctl的IPC_RMID操作。

PV操作：

sem = 1

P sem - 1 = 0

sem = 0 hello.c进程A可以使用

V sem = 1 hello.c进程B可以使用

创建semget：

函数的作用：创建信号量

函数的原型：int semget(key_t key,int nsems, int semflg);

函数的参数：nsems:信号量的数目，通常取1个

semflag:用open（）函数权限位

返回值：成功：信号量的标识符

出错：-1

控制 semctl:

函数的作用：信号量的控制：初始化、删除

函数的原型：int semctl(int semid,int semnum,int cmd,union semun,arg);

函数的参数：semnum:通常为0，第一个信号量

cmd: IPC_STAT:

IPC_SETVAL:设置为arg中的val的值

IPC_GETVAL:获取信号量的值

IPC_RMID:删除信号量

返回值：成功：cmd不同返回值也不一样

IPC_STAT、IPC_SETVAL、IPC_RMID:返回0

IPC_GETVAL:返回为信号量的值

PV操作semop:

函数的作用:执行PV操作

函数的原型：int semop(int semid,struct sembuf *sops, size_t nsops);

函数的参数：struct sembuf *sops:

sem_op: -1 P操作

1：V操作

nsops:-1

返回值：成功:信号量的标识符

出错：-1

PV操作举例：

sema.c:

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

int main()
{
    int fd = 0;
    int ret;
    int semid;

    struct sembuf sops;

    key_t key;

    key = ftok("/home/linx",1);

    semid = semget(key,1,IPC_CREAT);
    ret = semctl(semid,0,SETVAL,1);
    printf("Init value of sem is %d.\n",ret);

    fd = open("broad.txt",O_RDWR|O_CREAT|O_APPEND);
    sops.sem_num = 0;
    sops.sem_op = -1;
    semop(semid,&sops,1);

    write(fd,"class math",11);

    sleep(20);
    sops.sem_num = 0;
    sops.sem_op = +1;
    semop(semid,&sops,1);

    close(fd);

    return 0;
}

semb.c

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

int main()
{
    int fd = 0;

    key_t key;

    int semid;

    struct sembuf sops;

    key = ftok("/home/linux",1);

    semid = semget(key,1,IPC_CREAT);

    fd = open("./broad.txt",O_RDWR|O_CREAT|O_APPEND);
    sops.sem_num = 0;
    sops.sem_op = -1;
    semop(semid,&sops,1);

    write(fd,"english exam",20);
    sops.sem_num = 0;
    sops.sem_op = +1;
    semop(semid,&sops,1);

    close(fd);

    return 0;
}

执行sema.c semb.c的可执行文件之后，可以cat broad.txt查看结果。

秒客网

[Linux C编程]进程间的通信（二）

相关文章