【Linux】进程控制

已于 2023-08-01 10:23:37 修改
阅读量199 收藏
点赞数
分类专栏： Linux 文章标签： linux
于 2023-07-18 11:58:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64893500/article/details/131784228
版权

【Linux】进程控制

文章目录

1、进程创建（fork函数）

fork()函数是一个在Unix和类Unix操作系统中使用的系统调用，用于创建一个新的进程，称为子进程。子进程是父进程的一个副本，它从fork()函数的调用点开始执行。

以下是fork()函数的原型：

#include <unistd.h>

pid_t fork(void);

fork()函数返回两次：在父进程中返回子进程的进程ID（PID），在子进程中返回0。这样，通过检查返回值，可以确定当前代码是在父进程还是子进程中执行。

下面是一个简单的示例程序，展示了fork()函数的基本用法：

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

int main() {
    pid_t pid = fork();
    
    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Hello from the child process!\n");
    } else {
        // 父进程代码
        printf("Hello from the parent process! Child's PID is %d.\n", pid);
    }
    
    return 0;
}

当你运行上述程序时，它会创建一个子进程，并在父进程和子进程中分别输出不同的消息。你可以尝试运行这段代码，观察输出结果。

需要注意的是，fork()函数会将当前进程的整个地址空间（包括代码、数据和堆栈）复制到子进程中。因此，父进程和子进程将在fork()调用点之后的代码处开始并发地执行，但它们各自有自己的地址空间和系统资源。

1.1 调用过程

在调用fork()函数后，当控制转移到内核中的fork()代码时，内核会执行以下操作：

  1. 分配新的内存块和内核数据结构给子进程：内核会为子进程分配新的地址空间，并为其创建相应的内核数据结构，用于跟踪和管理子进程的状态和资源。

  2. 将父进程部分数据结构内容拷贝至子进程：内核会将父进程的一部分数据结构内容（如进程上下文、文件描述符表、信号处理程序等）拷贝到子进程的对应数据结构中。这样，子进程就成为了父进程的一个副本，但拥有自己的独立执行环境。

  3. 添加子进程到系统进程列表中：内核将子进程添加到系统的进程列表中，以便对其进行进程调度和管理。子进程会被分配一个唯一的进程ID（PID），以标识它在系统中的唯一性。

  4. fork()返回，开始调度器调度：在完成子进程的初始化之后，fork()函数会返回两次。在父进程中，返回子进程的PID（大于0）；在子进程中，返回0。接下来，内核会使用调度器决定如何分配CPU时间片，以允许父进程和子进程并发地执行。

需要注意的是，fork()函数只会复制父进程的数据结构，不会复制整个地址空间的内容。子进程与父进程共享父进程的物理内存页，这是通过页表机制实现的。只有在父进程或子进程中修改内存内容时，才会进行实际的复制操作（称为写时复制，Copy-on-Write）。

这些是fork()函数在内核中的一般操作。具体的实现可能会因操作系统的不同而有所差异。

写时拷贝

写时拷贝（Copy-on-Write，COW）是一种内存管理技术，常用于处理fork()函数创建子进程时的内存复制操作。

在初始阶段，父进程和子进程共享同一份物理内存页。这意味着它们访问相同的物理内存内容，并且在内核的页表中指向相同的页帧。这样可以节省内存和复制数据的时间。

当父进程或子进程尝试对这些共享内存页进行写入操作时，就会触发写时拷贝机制。内核会将相关的内存页复制一份，分配给修改数据的进程，而不影响其他进程。这样，父进程和子进程各自拥有了自己的独立内存副本，它们之间的写操作不再相互干扰。

写时拷贝的好处在于，只有在需要修改共享数据时才会进行复制操作，而在只读情况下，父进程和子进程共享同一份内存，节省了内存和复制的开销。

以下是写时拷贝的典型流程：

  1. fork()函数创建子进程。
  2. 父进程和子进程共享同一份物理内存页。
  3. 当父进程或子进程尝试对共享内存页进行写操作时，触发写时拷贝。
  4. 内核将相关的内存页复制一份，分配给修改数据的进程。
  5. 父进程和子进程分别拥有自己的独立内存副本。
  6. 父进程和子进程可以独立进行写操作，互不干扰。

写时拷贝技术在实现fork()函数时非常有用，因为它避免了不必要的内存复制，提高了性能和效率。

1.2 常规用法

fork()函数在常规用法中有两种常见情况：

  1. 创建子进程来执行不同的代码段：
    在这种情况下，父进程会调用fork()函数来创建一个新的子进程，然后父子进程可以并发地执行不同的代码段。

    示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        // 执行父进程特定的代码
    }

    return 0;
}

    在上述示例中，父进程和子进程根据fork()的返回值判断执行的代码段，从而实现了并发执行不同的代码。

  2. 子进程执行不同的程序（使用exec()函数）：
    在这种情况下，父进程通过fork()函数创建子进程，并且子进程在fork()返回后调用exec()函数来加载并执行一个全新的程序，替换自身的代码段和数据段。

    示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        execl("/bin/ls", "ls", "-l", NULL);
        // 如果exec函数调用成功，子进程的代码段和数据段将被替换为ls程序的代码段和数据段
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        wait(NULL); // 等待子进程执行完毕
        printf("Child process completed.\n");
    }

    return 0;
}

    在上述示例中，父进程创建子进程后，子进程调用execl()函数来加载并执行ls命令，替换自身的代码段和数据段。父进程在等待子进程执行完毕后继续执行。

这些是fork()函数的两种常见用法，用于实现父子进程的并发执行和执行不同的程序。通过结合其他系统调用，可以实现更丰富的进程间通信和控制。

1.3 调用失败原因

fork()调用失败的原因可能有以下几种：

  1. 系统中有太多的进程：在一个系统中，同时运行的进程数量是有限的。如果系统中已经达到了进程数量的上限，那么fork()调用就无法创建新的进程，从而失败。

    解决方法：可以通过增加系统的进程数量限制或者关闭一些不必要的进程来释放资源，以便fork()调用能够成功创建新的进程。

  2. 实际用户的进程数超过了限制：在某些系统上，每个用户都有一个进程数量的限制。如果一个用户已经达到了进程数量的限制，那么该用户的fork()调用也会失败。

    解决方法：可以增加用户的进程数量限制或者关闭该用户的一些不必要的进程，以便fork()调用能够成功创建新的进程。

  3. 系统资源不足：fork()调用需要分配新的内存空间和其他资源给子进程，如果系统资源不足，比如内存不足或者文件描述符达到上限，那么fork()调用也会失败。

    解决方法：释放一些系统资源，如关闭不必要的文件描述符，或者增加系统的资源限制，以便fork()调用能够成功分配所需的资源。

需要注意的是，fork()函数的失败并不一定是永久性的，可能是由于临时的系统状态或资源限制导致的。因此，如果fork()调用失败，可以适当延时并重试，或者采取相应的措施来解决资源问题。

另外，fork()函数在调用失败时会返回一个负值，通常是-1，可以通过检查返回值来判断fork()是否成功。

2、进程终止

2.1 进程退出场景

进程退出的场景可以分为以下几种情况：

  1. 代码运行完毕，结果正确：这是最理想的情况，代码成功完成了它的任务，并且得到了正确的结果。在这种情况下，进程可以通过返回0作为退出状态码来表示成功。

  2. 代码运行完毕，结果不正确：有时候，代码可能会完成执行，但是得到了不正确的结果。在这种情况下，进程可以通过返回一个非零的退出状态码来表示失败或错误。具体的退出状态码的含义可以根据具体的程序来定义，通常非零值表示出现了某种错误或异常情况。

  3. 代码异常终止：在某些情况下，代码可能会遇到无法处理的错误或异常情况，导致程序无法继续执行。这可能是由于内存访问错误、除零错误、无效的指针引用等引起的。在这种情况下，进程会异常终止，并且操作系统会捕获到异常，并可能采取一些默认的处理方式，如终止进程并生成错误报告。

在C语言中，程序可以通过在main()函数中使用return语句来指定进程的退出状态码。例如：

int main() {
    // 代码执行完毕，结果正确
    return 0;
}

int main() {
    // 代码执行完毕，结果不正确
    return 1;
}

对于异常终止的情况，操作系统通常会将非零的退出状态码返回给父进程，父进程可以根据这个状态码来判断子进程的异常终止原因。

需要注意的是，进程的退出状态码的具体含义可以根据程序的需求自定义。常见的做法是使用非零的状态码表示不同的错误或异常情况，方便在调用程序时进行错误处理和故障排除。

2.2 进程退出方法

2.2.1 正常终止

在进程中，常见的退出方法可以归纳为以下几种情况：

  1. 从main()函数返回：当程序执行完main()函数中的所有代码后，正常退出时会自动返回。返回的值会成为进程的退出状态码。通常情况下，返回0表示成功，非零值表示出现了错误或异常情况。

    示例代码：

    #include <stdio.h>

int main() {
    // 代码执行完毕
    return 0;
}

  2. 调用exit()函数：exit()函数是C标准库中的一个函数，可以用于显式地终止进程并指定退出状态码。

    示例代码：

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

int main() {
    // 代码执行完毕
    exit(0);  // 退出并返回状态码 0
}

  3. 通过信号终止：进程可以通过接收到特定的信号来终止。例如，通过在终端中按下Ctrl+C键，会发送一个SIGINT信号给进程，导致进程终止。在这种情况下，进程的退出状态码通常是非零值。

  4. return语句是一种常见的退出进程的方法，特别是在main()函数中。在C语言中，main()函数的返回值被视为进程的退出状态码，并且会被传递给系统的退出处理机制。

    根据C标准，如果main()函数中使用return语句显式返回一个值，这个返回值会被当做进程的退出状态码。这个退出状态码可以在其他程序中通过调用wait()或类似的函数来获取。

    示例代码：

    #include <stdio.h>

int main() {
    // 代码执行完毕
    return 0;  // 退出并返回状态码 0
}

    在这个示例中，main()函数使用return 0语句来表示正常终止，并将状态码0作为进程的退出状态码。

    需要注意的是，return语句在其他函数中的使用与进程的退出无关。在其他函数中，return语句是用于函数的返回值，而不是用于退出整个进程。

以上是进程常见的退出方法。可以通过检查进程的退出状态码来获取进程的退出状态信息，如在Linux终端中使用echo $?命令可以查看进程的退出码。

需要注意的是，不同的操作系统和编程语言可能会有不同的退出方法和约定。上述示例中的代码是基于C语言和类Unix系统的示例。

2.2.2 异常退出

调用_exit()或_Exit()函数：_exit()或_Exit()函数是系统调用，用于立即终止进程，不执行任何清理操作，直接返回到操作系统。这些函数通常在异常情况下使用，例如发生严重错误时。

示例代码：

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

int main() {
    // 发生错误，需要立即终止进程
    _exit(1);  // 立即退出并返回状态码 1
}
2.2.3 _exit与exit函数

_exit()函数和exit()函数都可以用于终止进程，但它们之间存在一些差异。

_exit()函数：

  • 是一个系统调用（system call），提供给操作系统使用。
  • 立即终止进程，不执行任何进程清理操作，包括不刷新缓冲区、不执行终止处理程序等。
  • 不会关闭打开的文件描述符，不会执行任何清理操作，也不会发送终止信号给父进程。
  • 其返回值直接传递给操作系统作为进程的退出状态码。

示例代码：

#include <unistd.h>

int main() {
    // 发生错误，需要立即终止进程
    _exit(1);  // 立即退出并返回状态码 1
}

exit()函数：

  • 是C标准库中的函数，提供给应用程序使用。
  • 终止进程前会执行一些清理操作，例如关闭文件描述符、刷新缓冲区、调用终止处理程序（通过atexit()注册的函数）等。
  • 最终会调用系统调用_exit()来终止进程。
  • 其返回值会传递给操作系统作为进程的退出状态码。

示例代码：

#include <stdlib.h>

int main() {
    // 代码执行完毕
    exit(0);  // 退出并返回状态码 0
}

在正常情况下，exit()函数和_exit()函数的使用方式和效果是相似的。但需要注意的是，由于exit()函数会执行一些清理操作，可能会导致一些未完成的I/O操作完成，因此在某些情况下，使用_exit()函数可以更加直接和快速地终止进程。

3、进程等待

3.1 进程等待必要性

进程等待是必要的，特别是在父进程需要获取子进程的退出状态、回收资源以及避免僵尸进程问题时。

以下是一些重要的原因：

  1. 避免僵尸进程：当子进程退出后，其进程描述符和其他资源仍然保留在系统中，这样的子进程称为僵尸进程。如果父进程不对子进程进行等待操作，僵尸进程可能会一直存在，导致资源泄漏和系统性能问题。

  2. 回收子进程资源：通过等待子进程，父进程能够及时回收子进程占用的资源，例如内存、打开的文件描述符等。这确保了系统资源的有效利用，防止资源泄漏。

  3. 获取子进程退出状态：等待子进程的另一个重要目的是获取子进程的退出状态码。退出状态码可以提供关于子进程执行的信息，例如是否成功执行、出现的错误类型等。父进程可以根据子进程的退出状态码采取相应的处理逻辑。

示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        exit(0);  // 子进程正常退出
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        wait(&status);  // 等待子进程退出
        if (WIFEXITED(status)) {
            int exit_status = WEXITSTATUS(status);
            printf("Child process exited with status: %d\n", exit_status);
        }
    }

    return 0;
}

在上述示例中，父进程通过调用wait()函数等待子进程的退出。然后，通过WIFEXITED和WEXITSTATUS宏，父进程获取子进程的退出状态码并进行相应的处理。

通过进程等待，父进程能够及时处理子进程的退出，回收资源，并获取子进程的退出状态信息，实现了进程间的协同与交互。

3.2 进程等待方法

在父进程中，可以使用以下方法来等待子进程的退出：

  1. wait()函数：wait()函数会使父进程阻塞，直到任一子进程退出。它会返回被等待子进程的进程ID，并通过指针参数获取子进程的退出状态信息。

    示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        return 0;
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        pid_t child_pid = wait(&status); // 等待任一子进程退出
        if (child_pid > 0) {
            if (WIFEXITED(status)) {
                int exit_status = WEXITSTATUS(status);
                printf("Child process %d exited with status: %d\n", child_pid, exit_status);
            }
        }
    }

    return 0;
}

  2. waitpid()函数：waitpid()函数可以等待指定的子进程退出。通过指定子进程的进程ID和选项，可以灵活地控制等待的行为。该函数也会返回子进程的进程ID，并通过指针参数获取子进程的退出状态信息。

    示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        return 0;
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        pid_t child_pid = waitpid(pid, &status, 0); // 等待指定子进程退出
        if (child_pid == pid) {
            if (WIFEXITED(status)) {
                int exit_status = WEXITSTATUS(status);
                printf("Child process %d exited with status: %d\n", child_pid, exit_status);
            }
        }
    }

    return 0;
}

以上是两种常用的等待子进程退出的方法：wait()和waitpid()。它们都提供了一种方式来等待子进程的退出，并获取子进程的退出状态码。

需要注意的是，wait()和waitpid()函数都会将父进程阻塞，直到子进程退出。可以通过设置选项和使用信号处理来灵活地控制等待的行为。

3.3 获取子进程status

wait()和waitpid()函数中的status参数是一个输出型参数，用于接收子进程的退出状态信息。如果传递NULL，则表示父进程不关心子进程的退出状态信息，而如果提供一个指向int类型的变量的指针，则操作系统会将子进程的退出信息填充到该变量中。

status参数可以被视为一个位图，其中不同的位表示了不同的退出状态信息。通过使用预定义的宏，可以从status参数中提取特定的退出状态信息。

一些常用的宏包括：

  • WIFEXITED(status): 如果子进程正常退出，则返回非零值。
  • WEXITSTATUS(status): 如果子进程正常退出，则返回子进程的退出状态码。
  • WIFSIGNALED(status): 如果子进程是由于信号而终止的，则返回非零值。
  • WTERMSIG(status): 如果子进程是由于信号而终止的，则返回导致子进程终止的信号编号。
  • WIFSTOPPED(status): 如果子进程当前处于停止状态，则返回非零值。
  • WSTOPSIG(status): 如果子进程当前处于停止状态，则返回导致子进程停止的信号编号。

示例代码：

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

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        // 错误处理
        fprintf(stderr, "Fork failed.\n");
        return 1;
    } else if (pid == 0) {
        // 子进程代码
        printf("Child process executing.\n");
        // 执行子进程特定的代码
        return 0;
    } else {
        // 父进程代码
        printf("Parent process executing.\n");
        int status;
        pid_t child_pid = wait(&status); // 等待子进程退出
        if (child_pid > 0) {
            if (WIFEXITED(status)) {
                int exit_status = WEXITSTATUS(status);
                printf("Child process %d exited with status: %d\n", child_pid, exit_status);
            }
        }
    }

    return 0;
}

在上述示例中，使用WIFEXITED()和WEXITSTATUS()宏来检查子进程是否正常退出，并获取子进程的退出状态码。

需要注意的是，status参数的具体格式和使用可能因操作系统的不同而有所差异。在特定的操作系统和环境下，可以查阅相关的文档来了解status参数的具体格式和可用的宏。

4、进程程序替换

4.1 替换原理

当一个进程调用exec()函数族中的某个函数时，该进程的用户空间代码和数据会完全被一个新程序替换，从新程序的启动例程开始执行。调用exec()函数并不会创建新的进程，因此进程的标识符（PID）在调用前后保持不变。

exec()函数族提供了多个函数，如execl(),execv(),execle(),execve()等，用于加载并执行一个新的程序。这些函数会接受一个可执行文件的路径，以及一系列的参数（命令行参数）来传递给新程序。

调用exec()函数族时，操作系统会执行以下步骤：

  1. 打开并读取指定的可执行文件。
  2. 创建一个新的地址空间，用于新程序的代码段、数据段和堆栈。
  3. 将可执行文件的代码和数据加载到新的地址空间。
  4. 设置新程序的入口点（启动例程）。
  5. 通过参数传递机制，将命令行参数传递给新程序。
  6. 清理原来进程的资源（代码、数据等）。
  7. 跳转到新程序的入口点开始执行。

因此，调用exec()函数后，原进程的代码和数据都被替换成了新程序的代码和数据，从而实现了进程的程序替换。新程序开始执行时，进程的标识符保持不变，因为进程并没有创建新的进程。

这种能力可以用于实现进程的动态加载和更新，以及执行不同的程序。通过fork()创建子进程，再在子进程中调用exec()函数，可以在子进程中执行不同的程序，实现更加灵活和多样化的应用场景。

需要注意的是，exec()函数调用成功后，原进程的代码和数据都被替换，之前的状态和执行上下文都会丢失。因此，在调用exec()函数之前，通常需要进行必要的清理和准备工作。

4.2 替换函数

在UNIX和类UNIX操作系统中，有六种以exec开头的函数，它们统称为exec函数。这些函数是exec()函数族的成员。

这六种函数是：

  1. execl()：用于在当前进程中执行一个新程序，并通过参数列表传递命令行参数。
  2. execle()：与execl()类似，但可以通过环境变量指定新程序的环境。
  3. execv()：用于在当前进程中执行一个新程序，并通过参数数组传递命令行参数。
  4. execve()：与execv()类似，但可以通过环境变量指定新程序的环境。
  5. execvp()：根据给定的文件名查找可执行文件，并在当前进程中执行该程序，通过参数数组传递命令行参数。
  6. execvpe()：与execvp()类似，但可以通过环境变量指定新程序的环境。

这些函数都可以用来加载并执行一个新的程序，将当前进程的用户空间代码和数据替换为新程序的代码和数据。它们可以根据需要选择不同的参数传递方式，例如使用参数列表或参数数组来传递命令行参数。

这些exec函数在实际使用中具有灵活性和可扩展性，可以满足不同的需求。通过调用这些函数，可以在当前进程中动态加载和执行不同的程序，实现进程的程序替换和更新。

需要注意的是，exec函数调用成功后，原进程的代码和数据都会被替换，之前的状态和执行上下文会丢失。因此，在调用这些函数之前，通常需要进行必要的清理和准备工作。

4.3 函数解释

对于exec函数族中的函数，如果调用成功，则加载新的程序并从新程序的启动代码开始执行，它们不会返回到原调用的位置。因此，如果exec函数成功执行，它们不会返回成功的返回值。

如果exec函数调用出错，则返回值为-1，表示调用失败。这通常是由于以下情况之一导致的：

  • 指定的可执行文件不存在或无法访问。
  • 没有足够的权限执行指定的可执行文件。
  • 指定的可执行文件格式不正确。

在调用exec函数失败后，原进程的状态和代码段保持不变，并可以根据返回值进行错误处理。

示例代码：

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

int main() {
    char* args[] = { "/path/to/executable", "arg1", "arg2", NULL };
    int ret = execvp(args[0], args);

    if (ret == -1) {
        perror("execvp");
        // 错误处理
        return 1;
    }

    // 不会执行到这里

    return 0;
}

在上述示例中，execvp()函数用于执行指定路径的可执行文件，并将命令行参数传递给新程序。如果execvp()调用失败，它会返回-1，并通过perror()函数打印出错误信息。

需要注意的是，成功的exec函数调用不会返回到原调用的位置，因为原进程的代码和数据已经被替换为新程序。如果希望在exec函数调用成功后执行某些操作，可以在exec函数调用前执行相应的代码。

exec函数只有出错的返回值，而没有成功的返回值。成功的调用会替换当前进程的代码和数据，从新程序的启动代码开始执行。

4.4 命名理解

exec函数族中的函数原型看起来相似，但掌握了一些规律后，它们就很容易记忆和理解。

以下是常见的命名规律：

  1. l（list）：这种形式的exec函数使用参数列表（list）来传递命令行参数。函数接受可变数量的参数，最后一个参数必须是NULL，用于表示参数列表的结束。

    示例：execl()

  2. v（vector）：这种形式的exec函数使用参数数组（vector）来传递命令行参数。函数接受一个指向参数数组的指针，其中数组的最后一个元素必须是NULL，用于表示参数数组的结束。

    示例：execv()

  3. p（path）：这种形式的exec函数会自动搜索环境变量PATH指定的目录来查找可执行文件。它们接受一个可执行文件的名称，而不需要提供完整的路径。

    示例：execvp()

  4. e（env）：这种形式的exec函数可以通过参数来指定新程序的环境变量。它们接受一个额外的参数，用于传递环境变量。

    示例：execle()

通过理解这些命名规律，我们可以根据函数的命名来推测函数的功能和使用方式。这样能够更轻松地选择适当的exec函数并正确使用它们。

需要注意的是，这些命名规律并不是绝对的，具体的函数实现和操作系统的差异可能会导致某些例外情况。因此，在使用exec函数时，最好参考相关的文档和标准规范，以确保使用正确的函数和参数。

5、简易shell

要编写一个简单的Shell，可以按照以下步骤进行循环处理：

  1. 获取命令行：从用户那里获取命令行输入，可以使用标准输入函数如fgets()来读取用户输入的命令行。

  2. 解析命令行：对获取到的命令行进行解析，将命令和参数分离。可以使用字符串处理函数如strtok()来拆分命令行字符串。

  3. 建立子进程（fork）：使用fork()函数创建一个子进程。子进程将用于执行用户输入的命令。

  4. 替换子进程（execvp）：在子进程中使用execvp()函数来替换子进程的代码和数据为用户输入的命令。通过传递解析得到的命令和参数数组给execvp()函数来执行相应的命令。

  5. 父进程等待子进程退出（wait）：在父进程中使用wait()或waitpid()函数等待子进程的退出。这样父进程就可以等待子进程执行完毕并获取子进程的退出状态。

整体的循环结构可以类似于以下示例代码：

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

#define MAX_COMMAND_LENGTH 100

int main() {
    while (1) {
        char command[MAX_COMMAND_LENGTH];
        printf("Shell> ");
        fgets(command, MAX_COMMAND_LENGTH, stdin);

        // 去除命令行末尾的换行符
        command[strcspn(command, "\n")] = '\0';

        // 解析命令行，获取命令和参数
        char* args[MAX_COMMAND_LENGTH];
        int arg_count = 0;
        char* token = strtok(command, " ");
        while (token != NULL) {
            args[arg_count] = token;
            arg_count++;
            token = strtok(NULL, " ");
        }
        args[arg_count] = NULL; // 参数数组最后一个元素必须为NULL

        pid_t pid = fork();

        if (pid < 0) {
            // 错误处理
            fprintf(stderr, "Fork failed.\n");
            return 1;
        } else if (pid == 0) {
            // 子进程执行命令
            execvp(args[0], args);

            // execvp调用失败
            fprintf(stderr, "Command not found.\n");
            exit(1);
        } else {
            // 父进程等待子进程退出
            int status;
            wait(&status);
        }
    }

    return 0;
}

在上述示例中，通过一个无限循环来持续接收用户输入的命令行。每次循环都会解析命令行、创建子进程、替换子进程执行命令，并在父进程中等待子进程退出。

需要注意的是，上述示例只是一个简单的Shell示例，可能还需要进行错误处理、环境变量的处理、重定向等更多的功能扩展。此外，还应考虑特殊命令（如退出Shell）的处理逻辑。

Bebop Primer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux进程控制
Junds0的博客
01-22 1991
第1关：进程等待 本关任务： 创建子进程； 等待子进程退出。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include<sys/types.h> #include<sys/wait.h> int g_i4event; int process_wait(void) { /********Begin****
深剖 Linux 进程控制
qq_61500888的博客
08-19 6610
带你一命通关 Linux 进程控制 十五分钟手撕进程控制原理
Linux进程控制（精讲）
热门推荐
2021dragon的博客
10-01 2万+
文章目录进程创建fork函数初始fork函数返回值写时拷贝fork常规用法fork调用失败的原因进程终止进程退出场景进程常见退出方法_exit函数exit函数return退出进程等待进程等待的必要性进程等待的方法wait方法waitpid方法获取子进程status具体代码实现进程程序替换替换原理替换函数函数解释命名理解做一个简易的shell 进程创建 fork函数初始 fork函数返回值 写时拷贝 fork常规用法 fork调用失败的原因 进程终止 进程退出场景 进程常见退出方法 _exit函数 exit函
操作系统——Linux 进程控制
CSH__的博客
06-25 1405
操作系统课设：实验二
Linux进程控制实验
qq_43796170的博客
11-22 4373
实验1：该实验有3个进程，其中一个为父进程，其余两个是该父进程创建的子进程，其中一个子进程运行“ls -l”指令，另一个子进程在暂停5s之后异常退出，父进程先用阻塞方式等待第一个子进程的结束，然后用非阻塞方式等待另一个子进程的退出，待收集到第二个子进程结束的信息，父进程就返回。 实现代码： /waitpid.c/ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <s
linux进程控制实验原理,实验三 Linux进程的创建与控制
weixin_34439836的博客
04-28 2064
实验三 Linux进程的创建与控制一、实验目的(1)加深对进程概念的理解，明确进程和程序的区别。(2)进一步认识并发执行的实质。(3)分析进程竞争资源现象，学习解决进程互斥的方法。(4)了解Linux系统中进程通信的基本原理。二、实验预备内容阅读Linux的fork.c源文件，分析进程的创建过程。三、实验内容1. 进程的家族关系在主程序中用3个fork()调用，最后输出一个字符或字符串，运行此简单...
linux进程控制实验心得,Linux学习心得12-进程管理
weixin_31971181的博客
04-28 2305
Linux操作系统包括三种不同类型的进程，每种进程都有自己的特点和属性：交互进程:由shell启动的进程。批处理进程:这种进程和终端没有联系，是一个进程序列。守护进程:在后台持续运行的进程。前台启动:一般地，用户键入一个命令，就已经启动了一个前台的进程。后台启动 :对于非常耗时进程，可以然进程在后台运行。从后台启动进程其实就是在命令结尾加上一个“&”号每个进程，都会对应一个父进程，而这个父...
实验五 linux进程控制,实验五 Linux进程管理和打印管理
weixin_28904055的博客
05-01 1758
实验五 Linux进程管理和打印管理实验五 Linux进程管理和打印管理一. 一. 实验目的：1． 1． 进行系统进程管理。2． 2． 配置Linux下的打印服务器，实现局域网内的Linux和Windows客户端共享使用服务器的打印机。二. 二. 实验内容：1． 1． 进程状态查看；2． 2． 控制系统中运行的进程；3． 3． 安排一次性和周期性自动执行的后台进程；4． 4...
实验四 linux进程控制实验报告,Linux系统进程控制操作系统实验报告4
weixin_42500369的博客
05-02 1430
实验课程名称：操作系统实验项目名称Linux系统进程控制实验成绩实验者专业班级组别同组者实验日期年月日第一部分：实验分析与设计(可加页)实验内容描述(问题域描述)要求：掌握Linux系统中进程控制原语fork( )、sleep( )、wait( )、exit( )、exec的使用方法。内容：在Linux系统中编写C程序，创建一个子进程。父进程和子进程交替运行。父进程先显示一次“Current ti...
Linux进程控制（详解）
梅山
03-26 4919
内容来自：爱编程的大丙 1. 进程概述 从严格意义上来讲，程序和进程是两个不同的概念，他们的状态，占用的系统资源都是不同的。 程序：就是磁盘上的可执行文件, 并且只占用磁盘上的空间，是一个静态的概念。 进程：被执行之后的程序叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程的都对应一个属于自己的虚拟地址空间，这是一个动态的概念。 1.1 并行和并发 CPU时间片 CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个和的情况下是怎么完成多任务处理的呢
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
linux实验四 进程控制实验
02-09
【进程控制实验】是Linux操作系统课程中的一个重要环节，旨在帮助学生深入理解进程的概念以及进程间的交互。通过实验，学生能够掌握以下关键知识点： 1. **进程的概念与程序的区别**： 进程是操作系统资源分配的...
linux进程控制演示代码.rar_Linux kill_Linux 进程控制_researchfoc_进程控制
09-23
`fork`, `kill`, 和 `waitpid` 是三个关键的系统调用，它们在Linux进程控制中扮演着至关重要的角色。这里我们将深入探讨这三个概念以及它们在实际编程中的应用。 1. **fork()**: `fork` 是一个特殊的系统调用，用于...
Linux 进程控制与进程互斥（附源代码）（附实验报告）
03-07
1、利用fork函数创建新进程，并根据fork函数的返回值，判断自己是处于父进程还是子进程中； 2、在新创建的子进程中，使用exec类的函数启动另一程序的执行；...5、分析Linux系统下多进程与多线程中的区别。
linux进程控制
09-14
linux进程控制
Linux：基础命令学习
qq_55038440的博客
07-20 1117
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
GNU/Linux - Bazaar版本管理工具
最新发布
guoqx的专栏
07-24 296
根据 Jelmer Vernooij 的说法，Canonical 的 Bazaar 团队的成员在 2012 年初被分配到不同的任务，他本人在7年来为该项目做出贡献后，于2012年底停止了对 Bazaar 的贡献。同样，Bugzilla项目在2014 3月从 Bazaar 改为使用 git，其中一个原因是 Bazaar 几乎已被放弃的印象：“每个月可能有 2-3 次向主干提交。并用来进行Ubuntu项目的版本控制。Bazaar 可以由一个开发本地内容的多个分支的开发人员使用，也可以由跨网络协作的团队使用。
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 1066
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 914
Shell脚本的使用
Linux 进程控制
07-01
Linux 进程控制是操作系统管理执行中的程序或线程的一种核心功能。它涉及到创建、调度、同步、通信和终止进程等多个方面。以下是一些关键概念： 1. **进程创建**：在Linux中，可以通过fork()和execve()系统调用来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值