1.进程的创建 编写一段程序，使用系统调用fork（）创建两个子进程。当此程序运行时， 在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字 符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。试观察记录屏幕上 的显示结果，并分析原因。 2.进程的控制 修改已编写的程序，将每个进程输出一个字符改为每个进程输出一句话，再 观察程序执行时屏幕上出现的现象，并分析原因。 如果在程序中使用系统调用lockf（）来给每一个进程加锁，可以实现进程 之间的互斥，观察并分析出现的现象。3.用fork()创建一个进程，再调用exec()用新的程序替换该子进程的内容； 利用wait()来控制进程执行顺序。

1. 进程的创建：

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

int main() {
    pid_t pid1, pid2;
    pid1 = fork();
    if (pid1 < 0) {
        printf("Fork failed!\n");
        return -1;
    }
    else if (pid1 == 0) {
        printf("Child 1: b\n");
    }
    else {
        pid2 = fork();
        if (pid2 < 0) {
            printf("Fork failed!\n");
            return -1;
        }
        else if (pid2 == 0) {
            printf("Child 2: c\n");
        }
        else {
            printf("Parent: a\n");
        }
    }
    return 0;
}

运行结果可能会有所不同，因为进程执行的顺序是不确定的。但是，通常情况下，父进程先输出“a”，然后是子进程1输出“b”，最后是子进程2输出“c”。

这是因为在调用fork()创建新进程时，操作系统无法保证哪个进程先运行。在这个例子中，父进程创建了两个子进程，但是先运行的进程是不确定的，因此输出结果是不确定的。

2. 进程的控制：

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

int main() {
    pid_t pid1, pid2;
    int fd;
    fd = open("output.txt", O_CREAT|O_WRONLY|O_APPEND, 0644); // 打开文件，如果不存在就创建
    if (fd < 0) {
        printf("Open failed!\n");
        return -1;
    }
    pid1 = fork();
    if (pid1 < 0) {
        printf("Fork failed!\n");
        return -1;
    }
    else if (pid1 == 0) {
        lockf(fd, F_LOCK, 0); // 加锁
        write(fd, "Child 1: I am a child process.\n", 32);
        lockf(fd, F_ULOCK, 0); // 解锁
    }
    else {
        pid2 = fork();
        if (pid2 < 0) {
            printf("Fork failed!\n");
            return -1;
        }
        else if (pid2 == 0) {
            lockf(fd, F_LOCK, 0); // 加锁
            write(fd, "Child 2: I am also a child process.\n", 38);
            lockf(fd, F_ULOCK, 0); // 解锁
        }
        else {
            lockf(fd, F_LOCK, 0); // 加锁
            write(fd, "Parent: I am the parent process.\n", 33);
            lockf(fd, F_ULOCK, 0); // 解锁
        }
    }
    close(fd);
    return 0;
}

运行结果是所有进程按顺序输出到文件output.txt中，因为使用了lockf()来确保进程之间的互斥。

3. 用fork()创建一个进程，再调用exec()用新的程序替换该子进程的内容；利用wait()来控制进程执行顺序。

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

int main() {
    pid_t pid;
    int status;
    pid = fork();
    if (pid < 0) {
        printf("Fork failed!\n");
        return -1;
    }
    else if (pid == 0) {
        printf("Child: Before exec(), PID is %d.\n", getpid());
        execl("/bin/ls", "ls", "-l", NULL); // 将子进程替换成新的程序
        printf("Child: After exec(), PID is %d.\n", getpid()); // 不会执行到这里
    }
    else {
        printf("Parent: Child PID is %d.\n", pid);
        wait(&status); // 等待子进程结束
        printf("Parent: Child exit status is %d.\n", WEXITSTATUS(status));
    }
    return 0;
}

运行结果是先输出“Child: Before exec()”，然后是ls命令执行的结果，最后输出“Parent: Child exit status is 0”。

这是因为使用了fork()创建了一个子进程，然后在子进程中使用execl()将进程替换成了新的程序/bin/ls，因此会先输出“Child: Before exec()”，然后执行ls命令并输出结果。最后，父进程会等待子进程结束，然后输出“Parent: Child exit status is 0”。