实验五 进程通信-管道通信

1. 函数int pipe(int fd[2])创建一个管道，管道两端可分别用描述字fd[0]以及fd[1]来描述。需要注意的是，管道的两端是固定了任务的。即一端只能用于读，由描述字fd[0]表示，称其为管道读端；另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。下面给出的程序使用系统调用pipe()建立一条管道线，两个子进程p1和p2分别向管道各写一句话：child1 is sending a message!和child2 is sending a message!，父进程则从管道中读出来自子进程的信息，并显示在屏幕上。请读懂程序并调试运行。

#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include<stdlib.h>
int pid1, pid2;
int main() {
	int fd[2];
	int pid1, pid2;
	char OutPipe[100], InPipe[100];

	pipe(fd);

	while ((pid1 = fork()) == -1);
	if (pid1 == 0) {
		printf("child process1 %d\n", getpid());
		lockf(fd[1], 1, 0);
		sprintf(OutPipe, "child1 is sending a message!");
		write(fd[1], OutPipe, 50);
		sleep(5);
		lockf(fd[1], 0, 0);
		exit(0);
	}
	else {
		while ((pid2 = fork()) == -1);
		if (pid2 == 0) {
			printf("child process2 % d\n", getpid());
			lockf(fd[1], 1, 0);
			sprintf(OutPipe, "child2 is sending a message!");
			write(fd[1], OutPipe, 50);
			sleep(5);
			lockf(fd[1], 0, 0);
			exit(0);
		}
		else {
			printf("parent process %d\n", getpid());
			wait(0);
			read(fd[0], InPipe, 50);
			printf("%s\n", InPipe);
			wait(0);
			read(fd[0], InPipe, 50);
			printf("%s\n", InPipe);
			exit(0);
		}
	}
}

阅读并运行程序并回答以下问题：
问题1：该程序中使用的管道是有名管道还是无名管道？程序中红色部分的含义是什么？
无名管道。锁定管道的写入端，从当前位置开始锁定。
问题2：程序的含义是什么？运行结果是什么？为什么？
这段代码创建了两个子进程，并使用管道来实现进程间通信。
运行结果：

出现该运行结果可能的原因是：
• 在程序运行时，两个子进程之间没有竞争管道写入权的情况发生。
• 在程序运行时，第一个子进程比第二个子进程先写入管道。

2.使用管道通信时，可关闭某些不需要的读或写描述符，建立起单向的读或写管道，然后用read和write像操作文件一样去操作它。下面给出的程序中子进程通过管道向父进程发送数据，这里子进程只使用到管道的写端口fd[1]、父进程使用到了fd[0]，因此可关闭子进程的fd[0]和父进程的fd[1]。请通过程序体会。

#include<sys/types.h> 
#include<unistd.h> 
#include<stdio.h> 
#include<stdlib.h> 
#include<errno.h> 
#include<memory.h>  
int main()
{
    char* msg = "I am child process!";
    /*子进程发送的数据*/
    pid_t pid;
    char buf[100];
    /*用于读取*/
    int pi;
    /*创建管道时的返回值*/
    int fd[2];
    /*创建管道的参数*/

    memset(buf, 0, sizeof(buf));
    /*设置buf数组全为0，需*/
    pi = pipe(fd);         					/*要引入#include<memory.h>*/
    if (pi < 0)
    {
        perror("pipe() error!");
        exit(0);
    }
    if ((pid = fork()) == 0)
        /*child process*/
    {
        close(fd[0]);
        /*关闭读管道*/
        if (write(fd[1], msg, 20) != -1)
            /*写入管道*/
            printf("child process write success!\n");
        close(fd[1]);
        /*关闭写管道*/
    }
    else if (pid > 0)					/*parent process*/
    {
        close(fd[1]);
        /*关闭写管道*/
        sleep(2);
        /*休眠一下等待数据写入*/
        if (read(fd[0], buf, 100) > 0)/*写入管道*/
            printf("Message from the pipe is:%s\n", buf);
        close(fd[0]);/*关闭读管道*/
        waitpid(pid, NULL, 0);
        /*待pid进程退出，此处pid为子进程*/
        exit(0);
    }
    else
    {
        perror("fork() error!");
        exit(0);
    }
}

3.普通管道只能用于一个进程家族之间的通信，如父子，兄弟之间，并且普通管道在于内存中，随着进程的结束而消失；而命名管道是有“名字”的管道，存在于磁盘上，作为一个特殊的设备文件而存在，不会随着进程结束而消失。有名管道可用于两个无关的进程之间的通信，实现函数是mkfifo()。下面的程序实例演示了mkfifo的使用。请先以超级用户身份登录系统，然后编辑/编译源程序（两个*.c程序），在图形终端上执行读程序readfifo.c，读程序执行后将陷入循环；切换到字符终端1（ctrl+alt+f1），以超级用户身份登录并执行写程序writefifo.c，然后回到图形终端，观察读程序的输出变化。

readfifo.c:

#include<sys/types.h> 
#include<unistd.h> 
#include<stdio.h> 
#include<stdlib.h> 
#include<errno.h> 
#include<fcntl.h> 
#include<sys/stat.h> 
#include<memory.h> 
#define FIFO "/home/ghj/myfifo" /*使用宏定义路径*/ 

int main()
{
    int fd;/*指向命名管道*/
    char buf[100];/*存储数据*/

    if (mkfifo(FIFO, O_CREAT | O_EXCL) < 0) /*创建管道*/
    {
        perror("Create error!\n");
        unlink(FIFO);/*清除管道*/
        exit(0);
    }
    fd = open(FIFO, O_RDONLY | O_NONBLOCK, 0);/*打开管道*/
    if (fd < 0) {
        perror("Create error!\n");
        unlink(FIFO);
        exit(0);
    }
    while (1) {
        memset(buf, 0, sizeof(buf));/*清空buf数组*/
        if (read(fd, buf, 100) > 0)/*读取管道*/
        {
            printf("Get message:%s\n", buf);
        }
        else {
            printf("Not accept any message!\n");
        }
        sleep(1);/*休眠*/
    }
}

writefifo.c:

#include<sys/types.h> 
#include<unistd.h> 
#include<stdio.h> 
#include<stdlib.h> 
#include<errno.h> 
#include<fcntl.h> 
#include<sys/stat.h> 
#define FIFO "/home/ghj/myfifo"/*宏定义命名管道路径*/ 

int main()
{
    char* msg = "Some message!";/*发送数据*/
    int fd;

    fd = open(FIFO, O_WRONLY | O_NONBLOCK, 0);/*打开*/
    if (write(fd, msg, 20) != -1)/*写信息*/
        printf("Message have been send to FIFO\n");
    exit(0);
}

本地运行结果出了点问题，这里就不展示运行结果图了。

4.编写两个程序client.c和server.c，分别用于消息的发送和接收。

client.c:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#define MSGKEY 75
struct msgform{
    long mtype;
    char mtext[1000];
}msg;
int msgqid;
void client(){
    int i;
    msgqid = msgget(MSGKEY, 0777);      /*打开75#消息队列*/
    for (i = 10; i >= 1; i--){
        msg.mtype = i;
        printf("(client)sent\n");
        msgsnd(msgqid, &msg, 1024, 0);    /*发送消息*/
    }
    exit(0);
}
int main(){
    client();

    return 0;
}

server.c:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#define MSGKEY 75
struct msgform{
    long mtype;
    char mtext[1000];
}msg;
int msgqid;
void server(){
    msgqid = msgget(MSGKEY, 0777 | IPC_CREAT);   /*创建75#消息队列*/
    do{
        msgrcv(msgqid, &msg, 1030, 0, 0);         /*接收消息*/
        printf("(server)received\n");
    } while (msg.mtype != 1);
    msgctl(msgqid, IPC_RMID, 0);     /*删除消息队列，归还资源*/
    exit(0);
}
int main(){
    server();
    
    return 0;
}

建议该题目的运行方法为：
将上述两个程序分别编译为server和client，并按以下方式执行：
./server & /*当在前台运行某个作业时，终端被该作业占据；而在后台运行作业时，它不会占据终端。可以使用&命令把作业放到后台执行。该命令的一般形式为：命令&*/
ipcs –q /* 输出有关信息队列(message queue)的信息*/
./client

阅读并运行程序并回答以下问题：
问题1：运行结果是什么？该程序为什么需要在后台运行server.c？若不如此会出现什么现象？为什么？

将服务器程序放在后台运行，会在客户端程序发送消息之前已经启动并创建了消息队列。如果不这样做，客户端程序可能会尝试打开一个不存在的消息队列，从而导致程序出错。
如果不将服务器程序放在后台运行，客户端程序可能会在服务器程序启动之前就尝试打开消息队列，导致错误。
问题2：两个程序的含义是什么？请解释其运行结果的含义？
server.c 和 client.c 两个程序分别实现了一个服务器和一个客户端，它们之间通过消息队列进行通信。
运行结果的含义是，服务器程序和客户端程序之间已经成功建立了连接，并且客户端程序已经发送了 10 条消息，服务器程序已经接收到了这些消息。