操作系统：实验三进程间通信实验

最新推荐文章于 2024-10-10 10:07:04 发布

OraOla

最新推荐文章于 2024-10-10 10:07:04 发布

阅读量990

点赞数 27

分类专栏：操作系统文章标签： linux

本文链接：https://blog.csdn.net/gyh3222719788/article/details/141724932

版权

操作系统专栏收录该内容

6 篇文章 1 订阅

订阅专栏

一、实验目的

1、了解什么是信号。

2、熟悉LINUX系统中进程之间软中断通信的基本原理。

3、理解进程的同步关系。

4、掌握用信号实现进程间的同步操作。

5、了解什么是管道。

6、熟悉UNIX/LINUX支持的管道通信方式。

二、实验内容

1、阅读下列程序，执行程序并给出结果截屏，分析程序功能。（2分）

（1）

#include<unistd.h>

#include<signal.h>

#include<stdio.h>

#include<stdlib.h>

#include<sys/types.h>

#include<sys/wait.h>

int k;

void func()

{   k=0; }

main()

{   int p;

        while((p=fork())==-1);

        if(p==0) //子进程

        {   k=1;

           signal(10,func);

           while(k!=0);

           printf("Child process is killed by parent!\n");

        }

        else //父进程

        {   sleep(1);

           kill(p,10);

           wait(0);

           printf("Parent process has killed!\n");

        }  

}

编译及执行过程和结果截屏：

程序实现功能（父进程和子进程分别做了什么？）：

父进程先执行，创建子进程后休眠 1 秒，然后向子进程发送信号，并等待子进程退出。在这种情况下，子进程接收到信号后，执行 func() 函数，将 k 置为 0，然后打印 "Child process is killed by parent!"。随后父进程继续执行，打印 "Parent process has killed!"。

子进程先执行，在接收到信号后执行 func() 函数，将 k 置为 0，然后退出。父进程接着执行，休眠 1 秒，然后尝试向已经退出的子进程发送信号，但是由于子进程已经退出，所以 kill() 函数失败。父进程继续执行，打印 "Parent process has killed!"。

父子进程竞争情况下，可能会出现不确定的结果。例如，父进程发送信号前子进程已经退出，这种情况下父进程会等待一个不存在的进程退出，可能会产生错误。

（2）

#include<unistd.h>

#include<signal.h>

#include<stdio.h>

int k=1;

void func()

{   k=0; }

main()

{

        signal(SIGINT,func);

        while(k!=0);

        printf("\n main process is killed by keybreak!\n");

}

编译及执行过程和运行结果截屏：

解释程序实现的功能：

1. 在程序运行期间，通过 `signal(SIGINT,func)` 函数调用注册了一个信号处理函数 `func()`。这意味着当程序接收到 `SIGINT` 信号时（通常由键盘输入 Ctrl+C 产生），将执行 `func()` 函数。

2. `func()` 函数被定义为将全局变量 `k` 的值设为 0。这表明当程序接收到 `SIGINT` 信号时，会将 `k` 的值修改为 0。

3. 主函数中的 `while(k!=0)` 循环会不断检查 `k` 的值是否为 0。如果 `k` 的值变为 0（即接收到了 `SIGINT` 信号），则循环结束。

4. 当循环结束时，程序会打印一条消息："main process is killed by keybreak!"。这条消息表明主进程由于键盘输入而被终止。

因此，该程序的功能是当用户在程序运行过程中按下 Ctrl+C 时，主进程会接收到 `SIGINT` 信号，执行 `func()` 函数将全局变量 `k` 的值设为 0，然后退出循环并打印提示消息，程序结束运行。

2、编写一段程序，使用系统调用fork()创建两个子进程，再用系统调用signal()让父进程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill()向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：

Child process 1 is killed by parent!

Child process 2 is killed by parent!

父进程等待两个子进程终止后，输出以下信息后终止：

Parent process is killed!

要求给出编译及执行过程和运行结果截屏。（2分）

#include<unistd.h>

#include<signal.h>

#include<stdio.h>

#include<stdlib.h>

#include<sys/types.h>

#include<sys/wait.h>



int k=1;



void func()

{

    k=0;

}



int main()

{

    signal(SIGINT, func);

    while (k != 0);

    int p1, p2;

    while ((p1=fork()) == -1);

    if (p1 == 0) // 第一个子进程

    {

        k=1;

        signal(10, func);

        while (k != 0);

        printf("Child process 1 is killed by parent!\n");

        exit(0);

    }

    else // 父进程

    {

        sleep(1);

        while ((p2=fork()) == -1);

        if (p2 == 0) // 第二个子进程

        {

            k=1;

            signal(10, func);

            while (k != 0);

            printf("Child process 2 is killed by parent!\n");

            exit(0);

        }

        else // 父进程

        {

            sleep(1);

            kill(p1, 10);

            kill(p2, 10);

            printf("Parent process is killed!\n");

        }  

    }



    return 0;

}

在父进程中，使用 signal(SIGINT, func) 注册了 SIGINT 信号的处理函数 func，这表示当父进程收到 SIGINT 信号（通常是通过键盘输入 Ctrl+C 产生）时，会将全局变量 k 设为 0。

父进程进入了一个无限循环，等待 k 的值变为 0。这意味着父进程会一直等待直到收到 SIGINT 信号，或者其他方式修改了 k 的值。

父进程创建了两个子进程 p1 和 p2。每个子进程执行类似的操作：在无限循环中等待 k 的值变为 0，然后输出相应的消息并终止。

在父进程中，先创建并杀死了第一个子进程 p1，然后创建并杀死了第二个子进程 p2。之后输出了 "Parent process is killed!" 消息。

为了演示父子进程之间的信号通信。父进程通过键盘输入 Ctrl+C 触发 SIGINT 信号，子进程通过 SIGUSR1 信号接收到父进程的通知，然后输出相应的消息。这种方式可以通过信号来实现进程之间的通信和协作。

3、编写程序，利用信号实现司机售票员同步操作问题。要求给出编译及运行过程和结果截图。（2分）

参考程序框架：

#include<unistd.h>

#include<signal.h>

#include<stdio.h>

#include<stdlib.h>

#include<sys/types.h>

#include<sys/wait.h>

int k;

void func()

{   k=0; }

main()

{   int p;

    int count=3;

    signal(12,func);      

    while((p=fork())==-1);

    if(p>0) //司机进程

    {   while(count)

        {   k=1;

           sleep(1);

           printf("driver:drive\n");

           printf("driver:stop\n");

               kill(p,10);         //发送信号给售票员

           while(k);

           printf("driver:start\n");

           count--;

        }

    }else //售票员进程

    {   signal(10,func);

        while(count)

        {   k=1;

           printf("conductor:sell ticket.\n");

           while(k);

           printf("conductor:open door.\n");

           printf("conductor:close door.\n");

  int ppid = getppid();     //取得司机进程的识别码

               kill(ppid,12); //发送信号给司机

           count--;

        }

    }

}

编译及执行过程和结果截屏：

1. 首先，在主函数中定义了两个变量 `p` 和 `count`。`p` 用于保存 `fork()` 函数的返回值，`count` 用于表示循环执行的次数。

2. 使用 `signal(12, func)` 注册了信号处理函数 `func()`，该函数在接收到编号为 12 的信号时会将全局变量 `k` 设为 0。编号为 12 的信号在程序中用于司机和售票员之间的通信。

3. 在一个循环中，通过 `fork()` 创建了子进程。父进程中 `p` 的值大于 0，而子进程中 `p` 的值等于 0。

4. 如果是父进程（司机进程），则执行如下操作：

- 将 `k` 设为 1，表示司机正在驾驶。

- 打印 "driver:drive"，表示司机正在驾驶。

- 打印 "driver:stop"，表示司机停车。

- 通过 `kill(p, 10)` 向售票员进程发送信号 10（`SIGUSR1`），告知售票员停车。

- 进入循环，等待售票员处理完毕（`k` 变为 0），然后再次开始驾驶。

5. 如果是子进程（售票员进程），则执行如下操作：

- 使用 `signal(10, func)` 注册了信号处理函数，该函数在接收到编号为 10 的信号时将 `k` 设为 0。

- 进入循环，等待司机停车信号。

- 收到司机停车信号后，将 `k` 设为 1，表示售票员正在处理。

- 打印 "conductor:sell ticket."，表示售票员正在售票。

- 发送信号 12（`SIGUSR2`）给司机进程，告知司机售票员已经完成任务。

- 等待司机开始行驶的信号。

6. 程序最终会按照循环的次数执行上述操作，直到循环结束。

4、编制一段程序，实现进程的管道通信。使用pipe()建立一条管道线。两个子进程p1和p2分别向管道各写一句话：

Child 1 is sending message!

Child 2 is sending message!

而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。（1分）

<参考程序>

#include<unistd.h>

#include<signal.h>

#include<stdio.h>

#include<stdlib.h>

int pid1,pid2;

main()

{   int fd[2];

    char OutPipe[100],InPipe[100];

    pipe(fd);

    while((pid1=fork())== -1);

    if(pid1==0)

    {   sprintf(OutPipe,"child 1 process is sending message!");

        write(fd[1],OutPipe,50);

        sleep(5);

        exit(0);

    }

    else

    {   while((pid2=fork())==-1);

        if(pid2==0)

        {   sprintf(OutPipe,"child 2 process is sending message!");

            write(fd[1],OutPipe,50);

            sleep(5);

            exit(0);

        }

        else

        {   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. 父进程创建了一个管道 `fd`，用于父子进程之间的通信。

2. 父进程通过 `fork()` 创建了第一个子进程 `pid1`。如果创建失败，则继续尝试创建，直到成功为止。

3. 如果当前进程是第一个子进程，则向管道中写入一条消息 "child 1 process is sending message!"，然后睡眠 5 秒后退出。

4. 如果当前进程是父进程，则继续创建第二个子进程 `pid2`，并进行类似的操作。

5. 如果当前进程是第二个子进程，则向管道中写入一条消息 "child 2 process is sending message!"，然后睡眠 5 秒后退出。

6. 父进程在两个子进程都退出后，使用 `wait()` 函数等待子进程退出，并通过管道读取两个子进程发送的消息。

7. 父进程读取管道中的消息，并打印输出。

总之该程序通过管道实现了父进程与两个子进程之间的通信，子进程向父进程发送了各自的消息，而父进程则接收并打印输出这些消息。

5、在父进程中用pipe()建立一条管道线，往管道里写信息，两个子进程接收父进程发送的信息。（2分）

#include <unistd.h>

#include <stdio.h>

#include <stdlib.h>

#include <sys/wait.h>

#include <string.h>



int main() {

    int fd[2];

    pid_t pid1, pid2;

    char message[] = "父进程发送给子进程的消息";



    char buffer[100];



    if (pipe(fd) < 0) {

        perror("管道创建失败");

        exit(EXIT_FAILURE);

    }



    if ((pid1 = fork()) < 0) {

        perror("子进程1创建失败");

        exit(EXIT_FAILURE);

    }



    if (pid1 == 0) {

        // 子进程1

        close(fd[1]); // 关闭管道写端

        read(fd[0], buffer, sizeof(buffer));

        printf("子进程1接收到: %s\n", buffer);

        close(fd[0]); // 关闭管道读端

        exit(EXIT_SUCCESS);

    }



    if ((pid2 = fork()) < 0) {

        perror("子进程2创建失败");

        exit(EXIT_FAILURE);

    }



    if (pid2 == 0) {

        // 子进程2

        close(fd[1]); // 关闭管道写端

        read(fd[0], buffer, sizeof(buffer));

        printf("子进程2接收到: %s\n", buffer);

        close(fd[0]); // 关闭管道读端

        exit(EXIT_SUCCESS);

    }



    // 父进程

    close(fd[0]); // 关闭管道读端

    write(fd[1], message, strlen(message) + 1);

    write(fd[1], message, strlen(message) + 1);

    close(fd[1]); // 关闭管道写端



    wait(NULL);

    wait(NULL);



    return 0;

}

父进程通过管道向两个子进程发送消息，并且两个子进程分别接收并输出这些消息。

1. 创建了一个管道 `fd`，用于父子进程之间的通信。

2. 父进程通过 `fork()` 创建了两个子进程 `pid1` 和 `pid2`。

3. 子进程1中，关闭了管道的写端，然后通过管道的读端接收父进程发送的消息，并打印输出。

4. 子进程2中，同样关闭了管道的写端，然后通过管道的读端接收父进程发送的消息，并打印输出。

5. 父进程中，关闭了管道的读端，然后通过管道的写端向管道中写入两条消息，然后关闭了写端。

6. 父进程使用 `wait()` 函数等待两个子进程退出。

总之该程序通过管道实现了父进程向两个子进程发送消息的功能，而两个子进程分别接收并输出了父进程发送的消息。

6、编程用管道实现父子进程间的双向通信。要求给出设计思路，调试通过的程序和编译执行过程以及结果截屏。（附加题）

设计思路：

父进程创建两个管道，一个用于父进程向子进程发送消息，另一个用于接收子进程发送的消息。父进程创建子进程。子进程同样创建两个管道，一个用于子进程向父进程发送消息，另一个用于接收父进程发送的消息。父进程和子进程可以根据需要进行读取和写入管道。当父进程需要向子进程发送消息时，它将消息写入第一个管道，子进程从该管道读取消息。当子进程需要向父进程发送消息时，它将消息写入第二个管道，父进程从该管道读取消息。父子进程之间需要遵循一定的通信协议，以确保消息的正确传递和处理。

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <string.h>



#define BUFFER_SIZE 100



int main() {

    int parent_to_child[2]; // 父进程向子进程发送消息的管道

    int child_to_parent[2]; // 子进程向父进程发送消息的管道

    pid_t pid;



    // 创建父进程向子进程发送消息的管道

    if (pipe(parent_to_child) == -1) {

        perror("pipe");

        exit(EXIT_FAILURE);

    }



    // 创建子进程向父进程发送消息的管道

    if (pipe(child_to_parent) == -1) {

        perror("pipe");

        exit(EXIT_FAILURE);

    }



    // 创建子进程

    pid = fork();

    if (pid == -1) {

        perror("fork");

        exit(EXIT_FAILURE);

    }



    if (pid == 0) { // 子进程

        close(parent_to_child[1]); // 子进程关闭向子进程发送消息的写端

        close(child_to_parent[0]); // 子进程关闭向父进程发送消息的读端



        // 子进程从父进程发送消息的管道读取消息并输出

        char buffer[BUFFER_SIZE];

        read(parent_to_child[0], buffer, BUFFER_SIZE);

        printf("子进程接收到父进程的消息：%s\n", buffer);



        // 子进程向父进程发送消息

        const char *msg_to_parent = "Hello, parent!";

        write(child_to_parent[1], msg_to_parent, strlen(msg_to_parent) + 1);



        exit(EXIT_SUCCESS);

    } else { // 父进程

        close(parent_to_child[0]); // 父进程关闭向子进程发送消息的读端

        close(child_to_parent[1]); // 父进程关闭向父进程发送消息的写端



        // 父进程向子进程发送消息

        const char *msg_to_child = "Hello, child!";

        write(parent_to_child[1], msg_to_child, strlen(msg_to_child) + 1);



        // 父进程从子进程发送消息的管道读取消息并输出

        char buffer[BUFFER_SIZE];

        read(child_to_parent[0], buffer, BUFFER_SIZE);

        printf("父进程接收到子进程的消息：%s\n", buffer);



        // 等待子进程退出

        wait(NULL);

    }



    return 0;

}