# 2017-2018-1 20155319 课堂实践及补充
2017-2018-1 20155319 课堂实践及补充
研究Linux下IPC机制：原理，优缺点，每种机制至少给一个示例
- 共享内存
- 管道
- FIFO
- 信号
- 消息队列
共享内存
- 共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据[1]：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。
代码示例：
#include<stdio.h>
#include<unistd.h>
int main()
{
int fd[2]; // 两个文件描述符
pid_t pid;
char buff[20];
if(pipe(fd) < 0) // 创建管道
printf("Create Pipe Error!\n");
if((pid = fork()) < 0) // 创建子进程
printf("Fork Error!\n");
else if(pid > 0) // 父进程
{
close(fd[0]); // 关闭读端
write(fd[1], "hello world\n", 12);
}
else
{
close(fd[1]); // 关闭写端
read(fd[0], buff, 20);
printf("%s", buff);
}
return 0;
}
管道
- 管道实际是用于进程间通信的一段共享内存，创建管道的进程称为管道服务器，连接到一个管道的进程为管道客户机。一个进程在向管道写入数据后，另一进程就可以从管道的另一端将其读取出来。
管道的特点：
1、管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
2、只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）。比如fork或exec创建的新进程，在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。当父进程与使用fork创建的子进程直接通信时，发送数据的进程关闭读端，接受数据的进程关闭写端。
3、单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
4、数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
代码示例：
static int pfd1[2], pfd2[2];
void TELL_WAIT(void)
{
if (pipe(pfd1) < 0 || pipe(pfd2) < 0)
printf("pipe error\n");
}
void TELL_PARENT(pid_t pid)
{
if (write(pfd2[1], "c", 1) != 1)
printf("write error\n");
}
void WAIT_PARENT(void)
{
char c;
if (read(pfd1[0], &c, 1) != 1)
printf("read error\n");
if (c != 'p')
{
printf("WAIT_PARENT: incorrect data\n");
return ;
}
}
void TELL_CHILD(pid_t pid)
{
if (write(pfd1[1], "p", 1) != 1)
printf("write error\n");
}
void WAIT_CHILD(void)
{
char c;
if (read(pfd2[0], &c, 1) != 1)
printf("read error\n");
if (c != 'c')
{
printf("WAIT_CHILD: incorrect data\n");
return ;
}
}
FIFO
- 命名管道是一种特殊类型的文件，它在系统中以文件形式存在。这样克服了管道的弊端，他可以允许没有亲缘关系的进程间通信。
创建管道的两个系统调用原型：
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *filename,mode_t mode); //建立一个名字为filename的命名管道，参数mode为该文件的权限（mode%~umask），若成功则返回0，否则返回-1，错误原因存于errno中。
eg.mkfifo( "/tmp/cmd_pipe", S_IFIFO | 0666 );
server:
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#define MAXLINE 1024
#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"
void Perror(const char *s)
{
perror(s);
exit(EXIT_FAILURE);
}
void server(int readfd, int writefd)
{
/* send msg */
int i = 0;
for (i; i<3; i++) {
char buff[MAXLINE] = {0};
sprintf(buff, "hello world %d", i);
int n = write(writefd, buff, strlen(buff));
sleep(1);
}
char buff[MAXLINE] = {0};
int n = read(readfd, buff, MAXLINE);
if (n > 0) {
printf("read from client:%s\n", buff);
}
}
int main()
{
int readfd, writefd;
/* create two FIFO; OK if they already exist */
if ((mkfifo(FIFO1, 0777) < 0) && (errno != EEXIST))
Perror("can't create FIFO1");
if ((mkfifo(FIFO2, 0777) < 0) && (errno != EEXIST)) {
unlink(FIFO1); /* rm FIFO1 */
Perror("can't create FIFO2");
}
printf("create fifo success\n");
/* 要注意open的顺序 */
readfd = open(FIFO2, O_RDONLY, 0);
writefd = open(FIFO1, O_WRONLY, 0);
printf("open fifo success\n");
/* 让FIFO在进程结束后自动删除 */
unlink(FIFO1);
unlink(FIFO2);
server(readfd, writefd);
return 0;
}
client:
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#define MAXLINE 1024
#define FIFO1 "/tmp/fifo.1"
#define FIFO2 "/tmp/fifo.2"
void Perror(const char *s)
{
perror(s);
exit(EXIT_FAILURE);
}
void client(int readfd, int writefd)
{
/* read msg */
int i = 0;
for (i; i<3; i++) {
char buff[MAXLINE] = {0};
int n = read(readfd, buff, MAXLINE);
if (n > 0) {
printf("read from server:%s\n", buff);
}
}
char *buff = "goodby server";
write(writefd, buff, strlen(buff));
}
int main()
{
int readfd, writefd;
/* create two FIFO; OK if they already exist */
if ((mkfifo(FIFO1, 0777) < 0) && (errno != EEXIST))
Perror("can't create FIFO1");
if ((mkfifo(FIFO2, 0777) < 0) && (errno != EEXIST)) {
unlink(FIFO1); /* rm FIFO1 */
Perror("can't create FIFO2");
}
/* 要注意open的顺序 */
writefd = open(FIFO2, O_WRONLY);
readfd = open(FIFO1, O_RDONLY);
client(readfd, writefd);
return 0;
}
信号
- 信号机制是unix系统中最为古老的进程之间的通信机制，用于一个或几个进程之间传递异步信号。信号可以有各种异步事件产生，比如键盘中断等。shell也可以使用信号将作业控制命令传递给它的子进程。
#include <sys/types.h>
#include <signal.h>
void (*signal(int sig,void (*func)(int)))(int); //用于截取系统信号，第一个参数为信号，第二个参数为对此信号挂接用户自己的处理函数指针。返回值为以前信号处理程序的指针。
eg.int ret = signal(SIGSTOP, sig_handle);
消息队列
- 消息队列是内核地址空间中的内部链表，通过linux内核在各个进程直接传递内容，消息顺序地发送到消息队列中，并以几种不同的方式从队列中获得，每个消息队列可以用IPC标识符唯一地进行识别。内核中的消息队列是通过IPC的标识符来区别，不同的消息队列直接是相互独立的。每个消息队列中的消息，又构成一个独立的链表。
消息队列克服了信号承载信息量少，管道只能承载无格式字符流。
代码实验：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h> //包含ftok
#include <sys/msg.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#define MSG_W 0200
#define BUF_SIZE 512
typedef struct msgbuf
{
long mtype ;
char mdata[BUF_SIZE] ;
} mymsg_t ;
int
main(int argc, char** argv)
{
int mqid ; //消息队列的描述符
size_t msglen ; //消息的长度
long msgtype ; //消息的类型
mymsg_t* ptr ; //消息结构的指针
//用户未按格式输入
if (argc != 3)
puts("usage: send <pathname> <type>") ;
msgtype = atoi(argv[2]) ;
//获取已存在消息队列的描述符
mqid = msgget(ftok(argv[1], 0), MSG_W) ;
//构造一条消息
ptr = calloc(sizeof(long) + msglen, sizeof(char)) ;
ptr->mtype = msgtype ;
snprintf(ptr->mdata, BUF_SIZE, "Hi,Boy~") ;
//发送消息
msglen = strlen(ptr->mdata) ;
msgsnd(mqid, ptr, msglen, 0) ;
exit(0) ;
}
