东南大学操作系统基础实验项目-CSDN博客

本文链接：https://blog.csdn.net/weixin_34547628/article/details/148445651

简介：在东南大学的操作系统课程实验一中，学生将学习文件读写和进程调用这两个操作系统的基本操作。通过C语言实现文件的读取与写入，理解缓冲区的使用，以及通过创建子进程和执行新的程序映像来探索进程调用的相关概念。实验报告记录了实验步骤、问题解决方案及理论理解，旨在帮助学生深化对操作系统核心原理的认识，并提升编程和理论知识。

1. 文件读写操作流程

1.1 文件操作基础

在计算机的世界里，文件系统管理着所有的存储介质，使得我们可以轻松地存储、检索和管理数据。文件系统主要负责数据的逻辑存储与访问，它支持的文件描述符是一个抽象的概念，允许程序以统一的方式对各种不同的文件类型进行操作。文件指针则是一个指向文件中某个位置的指针，用于实现文件的读写操作。

1.2 文件读写流程详解

文件操作流程涉及多个步骤，首先是打开文件，系统为此文件分配资源，并返回一个文件描述符以便后续的读写操作。文件在使用完成后必须关闭，释放相关资源。对于读写操作，系统支持顺序读写，即按照文件指针当前的位置进行读写，以及随机读写，即直接定位到文件中任意位置进行读写。缓冲区在文件操作中扮演着至关重要的角色，它是一个临时存储区，可以提高文件读写的效率，通过缓冲区管理可以有效控制数据的输入输出。

1.3 文件操作中的错误处理

在文件操作中，难免会遇到错误和异常。这时，需要依据返回的错误代码来判断错误的类型，并采取相应的处理策略。例如，文件不存在、权限不足、磁盘空间不足等错误，都需要程序根据错误代码做出适当反应，以保证程序的健壮性和用户数据的安全。

通过本章的学习，我们已经对文件读写操作的基础知识有了初步的了解。接下来的章节将深入探讨文件操作的具体实现和高级技术，让我们继续深入了解文件系统的世界。

2. 进程调用概念

2.1 进程基础知识

进程的定义与特性

进程是操作系统中一个非常重要的概念，它是一个实体，包含了正在执行的一个程序的动态表示。一个进程通常由程序、数据集以及进程控制块(PCB)三部分组成。程序是静态的代码，数据集是程序运行时需要用到的输入数据，而进程控制块是操作系统用来记录进程状态和属性的内部数据结构。在多任务操作系统中，可以同时存在多个进程，它们之间共享CPU、内存等资源。

进程具有以下特性： - 并发性：多个进程可以同时存在并执行。 - 独立性：每个进程拥有独立的地址空间。 - 动态性：进程的创建、调度、执行和消亡是一个动态过程。 - 异步性：进程执行的顺序和速度是不可预测的。

进程状态及其转换

进程在其生命周期中会经历不同的状态，这些状态之间的转换由操作系统的调度器管理。主要的进程状态包括： - 创建态：进程正在被创建，操作系统为其分配必要的资源。 - 就绪态：进程已经准备好运行，等待被CPU调度。 - 运行态：进程正在CPU上执行。 - 阻塞态：进程等待某些条件满足（例如，输入输出操作完成），不能继续执行。 - 终止态：进程执行完毕，操作系统回收其占用的资源。

进程状态之间的转换关系如下图所示：

graph LR
    A[创建态] --> B[就绪态]
    B --> C[运行态]
    C --> D[阻塞态]
    D --> E[就绪态]
    C --> F[终止态]

2.2 进程控制与通信

进程的创建与终止

在Unix-like系统中，进程由父进程创建，通过fork()系统调用实现。fork()会创建一个新的进程，称为子进程，子进程是父进程的副本，但拥有自己的独立地址空间。子进程一旦创建，两个进程（父进程和子进程）将独立运行，它们之间的联系主要是通过进程间通信机制。

进程终止是正常结束进程生命周期的过程，可以通过exit()系统调用显式地终止。系统调用结束后，进程释放所有已分配的资源，并向父进程返回状态码。

进程间的同步与互斥

多个进程可能会共享相同的资源，这可能导致竞态条件，其中进程间同步和互斥用来解决这类问题。同步确保进程按顺序访问资源，而互斥保证在任何时间只有一个进程可以访问资源。

同步和互斥的常见实现包括： - 互斥锁（Mutex）：保证共享资源的互斥访问。 - 信号量（Semaphore）：允许多个进程以一种协调的方式访问共享资源。 - 条件变量（Condition Variables）：用于进程间或线程间的同步。

进程通信的方法与实例

进程间通信（IPC）是实现不同进程间数据传输和同步操作的机制。常见的IPC方法包括： - 管道（Pipes）：是一种简单的IPC方式，适用于父子进程或兄弟进程间通信。 - 消息队列（Message Queues）：允许一个或多个进程向另一个进程发送格式化数据块。 - 共享内存（Shared Memory）：多个进程可以访问同一块内存区域，实现高效数据传输。 - 信号（Signals）：用于进程间的异步通知机制。

2.3 进程调度与管理

调度算法的原理与应用

进程调度是操作系统的核心功能之一，负责决定哪个就绪态的进程将获得CPU的控制权。常见的调度算法有： - 先来先服务（FCFS）：按照进程到达顺序进行调度。 - 短作业优先（SJF）：选择执行时间最短的进程。 - 时间片轮转（RR）：将CPU时间划分为若干个时间片，轮流给就绪态的进程使用。

不同的调度算法适用于不同的场景。例如，FCFS简单但可能导致较长的平均等待时间，而SJF虽然能减少平均等待时间，但可能导致饥饿现象。RR则能保证所有进程公平地获得CPU时间。

进程优先级与调度策略

操作系统为每个进程分配一个优先级，优先级高的进程更有可能先获得CPU。优先级可以是静态分配的，也可以是动态调整的。在某些系统中，优先级可以基于进程的行为（如I/O请求）动态调整，称为优先级翻转。

调度策略确保了系统资源的合理分配和高效利用。选择合适的调度策略可以提高系统的吞吐量、减少进程响应时间和增加CPU利用率。

在本章节中，我们深入探讨了进程调用的基础知识，包括进程的定义、状态及其转换，以及进程间的控制与通信方法。此外，还介绍了进程调度的算法原理和应用，以及进程优先级在调度策略中的重要性。进程管理是操作系统设计与实现中的核心问题，了解这些概念对于深入理解计算机系统的工作原理至关重要。

3. C语言文件操作函数使用

文件操作是C语言中不可或缺的一部分，特别是在进行系统编程或处理底层数据时。本章节将深入探讨C语言中文件操作相关的标准输入输出库函数以及系统调用函数，重点说明其功能、使用场景和高级操作。

3.1 标准输入输出库函数

C语言提供了标准输入输出库（stdio.h），它为程序员提供了便捷的文件读写操作方法。本节将深入解析最常用的printf和scanf函数，并讨论文件指针与标准I/O库之间的关系。

3.1.1 printf与scanf的深入解析

printf 和 scanf 函数是标准输入输出库中用于格式化数据输入输出的两个基本函数。它们可以处理不同类型的数据，并将它们转换为指定的格式输出到文件或控制台，或者从文件或控制台读取并转换为程序中指定的数据类型。

#include <stdio.h>

int main() {
    int i = 10;
    double d = 3.14;
    printf("Integer: %d, Double: %f\n", i, d);
    scanf("%d %lf", &i, &d);
    return 0;
}

代码逻辑解读：

在代码块中， printf 函数用于将整型变量 i 和双精度浮点型变量 d 按照字符串格式输出。
scanf 函数用于从标准输入读取一个整数和一个双精度浮点数，并分别存入变量 i 和 d 。

printf 和 scanf 的格式化字符串中的转换说明符分别控制如何输出和读取变量。例如， %d 表示输出或读取一个十进制整数， %f 用于浮点数。

3.1.2 文件指针与标准I/O库

标准I/O库使用文件指针来访问文件，这是 FILE 类型的指针。每个 FILE 对象都关联到一个打开的文件，并提供一个操作该文件的接口。

#include <stdio.h>

int main() {
    FILE *file = fopen("example.txt", "w");
    if (file == NULL) {
        perror("Unable to open file");
        return 1;
    }
    fprintf(file, "Hello, world!\n");
    fclose(file);
    return 0;
}

代码逻辑解读：

使用 fopen 函数打开一个文件，并创建一个 FILE 指针 file 。参数 "example.txt" 是文件名， "w" 表示以写入模式打开文件。
fprintf 函数通过 file 指针写入字符串到文件中。
使用 fclose 函数关闭文件，释放相关资源。

FILE 指针将程序和文件相关联，使程序能够对文件执行各种读写操作。使用完文件后，一定要关闭文件，以确保所有缓冲区内的数据被正确写入磁盘，并释放系统资源。

3.2 系统调用函数

C语言中的系统调用函数提供了底层文件操作的能力。它们通过操作系统内核提供的接口来访问文件系统。在本节中，我们将讨论 open 、 read 、 write 、 close 、 lseek 和 fcntl 等函数，并探究其用途与实际使用方法。

3.2.1 open、read、write与close的使用

系统调用函数 open 用于打开一个文件， read 和 write 用于读取和写入数据， close 用于关闭文件。它们是实现文件I/O操作的基础。

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDWR | O_CREAT, 0666);
    if (fd == -1) {
        perror("Unable to open file");
        return 1;
    }

    char buffer[] = "This is a test.\n";
    write(fd, buffer, sizeof(buffer));

    close(fd);
    return 0;
}

代码逻辑解读：

使用 open 函数以读写方式( O_RDWR )打开文件，并创建文件( O_CREAT )，如果文件不存在的话。
write 函数将数据写入文件。
完成操作后，使用 close 函数关闭文件描述符 fd 。

使用这些函数时，必须注意返回值。如果操作失败，如文件打开失败，这些函数通常返回-1，因此检查返回值并进行错误处理是很重要的。

3.2.2 lseek与文件定位

lseek 函数用于改变文件流中的文件指针位置，它允许文件读写操作从文件的任意位置开始。

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDWR);
    if (fd == -1) {
        perror("Unable to open file");
        return 1;
    }

    lseek(fd, 0, SEEK_END); // Move to the end of the file

    char buffer[] = "\nAppended data.";
    write(fd, buffer, sizeof(buffer));

    close(fd);
    return 0;
}

代码逻辑解读：

打开文件后，使用 lseek 函数将文件指针移动到文件的末尾。
使用 write 函数在文件末尾追加数据。

通过 lseek 函数，可以灵活控制文件读写的位置，这对于文件编辑、随机访问等场景非常有用。

3.2.3 fcntl与文件属性控制

fcntl 函数是一个多功能的文件控制函数，它提供了对文件描述符进行控制的多种操作，包括改变文件的打开模式、设置文件锁等。

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Unable to open file");
        return 1;
    }

    int flags = fcntl(fd, F_GETFL);
    printf("The file's current flags are: %o\n", flags);

    // Set the file to be non-blocking
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

    close(fd);
    return 0;
}

代码逻辑解读：

打开文件后，使用 fcntl 函数获取文件的打开标志。
打印当前文件的状态标志。
使用 fcntl 函数将文件设置为非阻塞模式。
关闭文件。

fcntl 函数的使用较为复杂，通常用于改变文件属性、获取文件状态或对文件描述符执行特定控制操作。它的灵活性非常高，但需要更深入的了解和谨慎使用。

3.3 高级文件操作

C语言提供的文件操作函数不限于基本的读写。本节探讨非阻塞I/O、异步I/O以及文件锁机制，这些都是进阶话题，对于需要处理并发或同步问题的程序尤其重要。

3.3.1 非阻塞I/O与异步I/O

非阻塞I/O允许程序在读写操作未完成时继续运行，而不是在文件系统上等待。异步I/O则允许读写操作在后台执行，允许程序执行其他任务直到操作完成。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd = open("example.txt", O_RDONLY | O_NONBLOCK);
    if (fd == -1) {
        perror("Unable to open file");
        return 1;
    }

    char buffer[1024];
    ssize_t bytes_read;

    bytes_read = read(fd, buffer, sizeof(buffer));
    if (bytes_read == -1 && errno == EAGAIN) {
        printf("No data to read at the moment (non-blocking)\n");
    } else if (bytes_read > 0) {
        printf("Read %zd bytes\n", bytes_read);
    } else {
        printf("Error\n");
    }

    close(fd);
    return 0;
}

代码逻辑解读：

在打开文件时，我们添加了 O_NONBLOCK 标志，使得文件操作变为非阻塞模式。
尝试使用 read 函数读取文件，如果没有数据可读，会立即返回并设置 errno 为 EAGAIN 。

这些高级I/O操作允许程序更有效地处理I/O操作，尤其是在高并发环境下，但它们也引入了更多的复杂性和错误处理需求。

3.3.2 文件锁机制与应用场景

文件锁机制可以防止多个进程同时修改同一个文件，从而避免数据不一致的问题。在需要进行文件共享访问的场景中，文件锁是必不可少的。

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int fd = open("example.txt", O_RDWR);
    if (fd == -1) {
        perror("Unable to open file");
        return 1;
    }

    // Attempt to get an exclusive lock on the entire file
    struct flock fl;
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;
    fl.l_start = 0;
    fl.l_len = 0;

    if (fcntl(fd, F_SETLK, &fl) == -1) {
        if (errno == EACCES || errno == EAGAIN) {
            printf("File is locked by another process\n");
        } else {
            perror("fcntl");
        }
    } else {
        printf("Obtained lock on the file\n");
    }

    // Do file operations here ...

    // Unlock the file
    fl.l_type = F_UNLCK;
    fcntl(fd, F_SETLK, &fl);

    close(fd);
    return 0;
}

代码逻辑解读：

打开文件以读写模式。
定义一个 flock 结构，设置锁类型为 F_WRLCK （写锁），表示我们要锁定文件。
使用 fcntl 函数尝试获取文件锁，如果无法获取，则根据错误码进行处理。
完成操作后，释放锁。

文件锁的使用通常是在处理并发写入时保护数据的一致性和完整性。正确地使用文件锁可以有效防止竞态条件和数据损坏。

本章节深入分析了C语言中的文件操作函数使用，从基础到高级，涉及了标准输入输出库函数和系统调用函数，以及高级文件操作。在了解了这些操作的机制后，读者应能够根据具体需求选择合适的文件操作方法，并有效地实现文件的读写功能。在下一章节中，我们将探讨子进程的创建与管理，进一步加深对进程操作的理解。

4. 子进程创建与管理

4.1 子进程创建机制

4.1.1 fork函数的工作原理

fork() 是Unix和类Unix操作系统中的系统调用，它用于创建一个与当前进程几乎完全相同的子进程。 fork() 的执行会导致当前进程的执行流程分为两个分支：父进程和子进程。子进程是父进程的一个副本，它复制父进程的数据段、堆、栈以及打开的文件描述符等信息。在调用 fork() 之后，有两个进程运行相同的代码，但是它们的返回值不同：父进程获得的是子进程的 PID，子进程获得的是 0。

在讨论 fork() 之前，需要注意的是其返回值，根据手册（manpage）的描述：

如果 fork() 成功执行，那么在父进程中它返回新创建子进程的PID，而在子进程中返回值为0。
如果 fork() 失败，它将返回一个负值，并设置errno来表示错误的类型。

4.1.2 子进程的创建与执行流程

让我们以一个简单的例子来说明如何使用 fork() 创建子进程：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork(); // 调用fork()

    if (pid == -1) {
        // fork失败
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("I am the child process, PID: %d\n", getpid());
        // 在子进程中执行其他任务...
    } else {
        // 父进程代码
        printf("I am the parent process, PID: %d. My child is: %d\n", getpid(), pid);
        // 在父进程中执行其他任务...
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

在上面的程序中，我们首先调用了 fork() ，然后根据返回值来决定接下来的执行流程。子进程将打印其 PID，并执行其他任务。父进程打印其 PID 和子进程的 PID，并等待子进程结束。

4.1.3 子进程的执行行为

子进程从 fork() 返回后开始执行，它继承了父进程的所有资源，包括：

打开的文件描述符
内存映像和变量的副本
环境变量
已安装的信号处理程序

但是，子进程获得的是父进程数据的副本，对子进程的更改不会影响父进程。如果需要子进程与父进程共享资源，通常会使用 IPC（Inter-Process Communication）机制。

子进程的执行由操作系统的进程调度器进行调度，它和父进程以及其他进程一起竞争 CPU 时间片。

4.1.4 子进程的创建实例

以下是一个使用 fork() 创建子进程的完整示例，它创建了一个子进程，并在父子进程中都执行了一个循环。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork(); // 创建子进程

    if (pid < 0) {
        // fork失败
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程执行代码
        printf("I am the child process, PID: %d\n", getpid());
        for (int i = 0; i < 3; i++) {
            printf("Child process: %d\n", i);
            sleep(1); // 等待1秒
        }
        return 0; // 子进程退出
    } else {
        // 父进程执行代码
        printf("I am the parent process, PID: %d. My child is: %d\n", getpid(), pid);
        for (int i = 0; i < 3; i++) {
            printf("Parent process: %d\n", i);
            sleep(1); // 等待1秒
        }
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

在这个例子中，父子进程都会打印消息，并执行一个简单的循环。子进程通过返回 0 通知父进程它已经完成任务并退出。父进程在子进程完成前，使用 wait() 函数等待子进程结束，以防止子进程变成僵尸进程。

4.2 进程间关系与回收

4.2.1 父子进程间的资源共享

父子进程在创建后拥有相同的地址空间和资源的副本，但是它们是独立的进程，有各自的进程ID。子进程从 fork() 返回后，可以在不影响父进程的情况下更改自己的资源。

在多数情况下，父子进程之间需要进行数据交换或者共享某些资源。这通常通过以下几种机制实现：

文件描述符的继承：子进程默认继承父进程打开的文件描述符，因此父子进程可以对同一文件同时进行读写。
管道和FIFO：这些可以用于进程间的通信。
共享内存：允许不同进程共享内存区域，实现快速的数据交换。
消息队列和信号量：用于进程间同步和数据交换。

4.2.2 zombie进程的处理与避免

当子进程退出时，它并不会立即从系统中清除，而是变成一个 zombie 进程，直到父进程调用 wait() 或 waitpid() 来回收它的状态。Zombie 进程会占用系统资源，比如进程表条目，因此应该尽量避免它们的产生。

处理 Zombie 进程的一种方法是确保父进程及时调用 wait() ，或在子进程被创建后立即使用 signal(SIGCHLD, SIG_IGN) 忽略子进程的结束信号，让系统自行回收 zombie 进程。

4.2.3 避免僵尸进程的代码示例

在以下代码中，我们将在子进程中调用 _exit() 来结束，这样可以避免僵尸进程的产生，因为 _exit() 会立即释放资源。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

void child_process() {
    printf("Child process, PID: %d\n", getpid());
    // 使用 _exit() 正确地结束子进程
    _exit(EXIT_SUCCESS);
}

int main() {
    pid_t pid = fork(); // 创建子进程

    if (pid < 0) {
        // fork失败
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        child_process(); // 调用子进程函数
    } else {
        // 父进程
        wait(NULL); // 等待子进程结束
        printf("Parent process, PID: %d. Child process is terminated.\n", getpid());
    }

    return 0;
}

在这个例子中，子进程使用 _exit() 而不是 exit() 来结束，因为 _exit() 直接向内核报告子进程的结束，而 exit() 需要调用用户空间的退出处理程序，可能会产生 zombie 进程。

4.3 管道与信号

4.3.1 管道通信机制及其限制

管道是 Unix 系统中进程间通信的一种方式。通过管道，一个进程的输出可以成为另一个进程的输入。管道分为两种类型：无名管道和命名管道。

无名管道：通常用于父子进程或兄弟进程之间的通信。它存在于内存中，当所有使用它的进程都结束时，管道也会消失。
命名管道：使用 FIFO 文件实现，允许不相关的进程间通信。

管道通信的限制包括：

只能用于单向通信。
通信的双方需要有明确的父子关系或者需要事先创建管道文件。
管道中只能传输字节流，不能传输任意的结构化数据。

4.3.2 信号处理与进程通信

信号是进程间通信的一种形式，允许进程通知其他进程发生了某个事件。每个信号都有一个唯一的名称和编号，例如 SIGINT、SIGTERM、SIGKILL 等。

进程可以使用以下方式处理信号：

忽略信号：使用 signal() 或 sigaction() 设置信号处理函数为 SIG_IGN 。
捕捉信号：设置自定义的信号处理函数。
默认行为：让进程接收到信号后，按默认方式处理。

下面是一个简单的例子，展示如何捕捉 SIGINT 信号。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handle_signal(int sig) {
    printf("Signal %d caught! Exiting...\n", sig);
    exit(0);
}

int main() {
    // 设置 SIGINT 的处理函数
    signal(SIGINT, handle_signal);
    while (1) {
        printf("Process is running. Press Ctrl+C to send SIGINT...\n");
        sleep(1);
    }
    return 0;
}

在这个例子中，当用户按下 Ctrl+C 时，进程会接收到 SIGINT 信号，并调用 handle_signal 函数来处理信号并退出。

4.3.3 管道与信号的实际应用

在实际应用中，管道和信号通常一起用于复杂进程间的通信和控制。

例如，一个父进程创建多个子进程，子进程之间通过管道共享数据，父进程通过信号来控制子进程的结束。下面的例子使用无名管道来共享数据，并通过信号来控制进程的结束。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

#define BUFFER_SIZE 10

int main() {
    int fd[2]; // 管道文件描述符
    pid_t pid;

    // 创建管道
    if (pipe(fd) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid = fork(); // 创建子进程
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // 子进程
        close(fd[1]); // 关闭写端
        char buffer[BUFFER_SIZE];
        int bytes_read;

        // 从管道读取数据
        while ((bytes_read = read(fd[0], buffer, BUFFER_SIZE)) > 0) {
            write(STDOUT_FILENO, buffer, bytes_read);
        }
        write(STDOUT_FILENO, "\n", 1);
        close(fd[0]); // 关闭读端
        exit(EXIT_SUCCESS);
    } else {
        // 父进程
        close(fd[0]); // 关闭读端
        char buffer[BUFFER_SIZE];
        write(fd[1], "Hello, child!", BUFFER_SIZE);
        close(fd[1]); // 关闭写端
        sleep(1); // 等待子进程结束

        // 发送 SIGTERM 信号给子进程
        if (kill(pid, SIGTERM) == -1) {
            perror("kill");
            exit(EXIT_FAILURE);
        }
        wait(NULL); // 等待子进程结束
    }

    return 0;
}

在这个例子中，父进程向子进程通过管道发送一个字符串，子进程从管道读取数据并打印。父进程在子进程结束前发送 SIGTERM 信号，并使用 wait() 等待子进程结束。这样就展示了如何结合使用管道和信号来完成进程间的通信和控制。