计算机基础之操作系统——进程与线程管理（二）

1、进程的状态有哪些？

新建（New）：当一个进程刚刚被创建时，它处于新建状态。在这个状态下，操作系统为进程分配必要的资源，如内存、文件描述符等，并初始化进程控制块（PCB）等数据结构。
就绪（Ready）：进程已经准备好运行，正在等待操作系统调度器分配CPU时间片。就绪状态的进程已分配到了除CPU之外的所有必要资源，只需要CPU时间片就可以开始执行。
运行（Running）：进程正在CPU上执行。在任何给定时刻，每个CPU或核心上最多只能有一个进程处于运行状态。
阻塞（Blocked）：进程因等待某个事件（如I/O操作完成、锁释放或信号到达）而暂停执行。在阻塞状态下，进程无法继续执行，直到等待的事件发生。
终止（Terminated）：进程已经完成执行或因某种原因被终止。在终止状态下，进程的资源被回收，进程控制块（PCB）可能被保留一段时间以便父进程获取子进程的退出状态。

2、进程如何创建的？

在类 Unix 系统（如 Linux）中，进程创建通常分为两步：

fork()：复制当前进程（父进程）创建一个子进程。
exec()：子进程加载并执行新的程序代码（替换原有代码段）。

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

int main() {
    pid_t pid = fork(); // 创建子进程
    if (pid == 0) {     // 子进程执行
        execlp("/bin/ls", "ls", "-l", NULL); // 加载新程序
    } else {            // 父进程执行
        wait(NULL);     // 等待子进程结束
    }
    return 0;
}

操作系统内部的详细流程：

调用fork()系统调用：进程创建通常从一个已有的进程（父进程）开始。父进程调用fork()系统调用来创建一个新的进程（子进程）。fork()系统调用会复制父进程的进程控制块（PCB）、虚拟内存布局、文件描述符等数据结构，从而创建一个与父进程几乎完全相同的子进程。fork()调用在父进程中返回子进程的进程ID，而在子进程中返回0。
子进程修改内存映射：在fork()之后，子进程通常需要修改其虚拟内存映射，以实现写时复制（Copy-on-Write, COW）机制。写时复制是一种内存优化技术，它允许子进程在创建时共享父进程的内存页面，直到需要修改页面内容时才复制页面。这种机制避免了不必要的内存复制，提高了进程创建的性能。
调用exec()系统调用：如果子进程需要执行与父进程不同的程序，可以调用exec()系统调用来替换当前的程序映像。exec()系统调用会加载新程序的代码和数据到内存，然后设置程序计数器（Program Counter）指向新程序的入口点。需要注意的是，exec()调用会替换子进程的程序映像，但不会影响进程控制块（PCB）、文件描述符等数据结构。
子进程开始执行：子进程开始执行新程序或继续执行父进程的代码。通常，子进程会根据fork()或exec()的返回值来判断自己的角色，并执行相应的逻辑。例如，子进程可能会关闭不需要的文件描述符、初始化资源或启动新的线程等。
父进程等待子进程（可选）：父进程可以选择等待子进程的完成，以获取子进程的退出状态和回收资源。在类Unix系统中，wait()或waitpid()系统调用可以用于等待子进程。当子进程结束时，操作系统会发送一个SIGCHLD信号通知父进程，父进程可以捕获该信号并处理子进程的退出事件。

3、如何回收线程？

线程回收是指在一个线程完成执行后，释放其占用的资源并清除相关数据结构的过程。

线程回收的方法取决于具体的编程语言和操作系统，可以使用 join() 方法、线程分离（detach）或线程局部存储（TLS）等技术来实现线程回收。

使用 join() 方法

在很多编程语言和库中（如C++11中的std::thread、Python的threading模块等），线程对象通常提供了一个join()方法。通过调用该方法，主线程（或其他线程）可以等待目标线程完成，并在完成后回收资源。使用join()方法的好处是可以确保目标线程的资源被正确回收，避免内存泄漏和僵尸线程等问题。

C++：

#include <iostream>
#include <thread>

void thread_function() {
    std::cout << "Hello, I am a new thread!" << std::endl;
}

int main() {
    std::thread t(thread_function);
    t.join(); // 等待线程t完成，并回收资源
    return 0;
}

Python：

import threading

def thread_function():
    print("Hello, I am a new thread!")

t = threading.Thread(target=thread_function)
t.start()
t.join()  # 等待线程t完成，并回收资源

使用线程分离（detach）

在某些情况下可能不需要等待线程完成，而只需确保线程在退出时自动回收资源。这时可以使用线程分离（detach）方法。例如，在C++11的std::thread中，可以调用detach()方法将线程设置为分离状态。分离状态的线程在完成执行后会自动释放资源，无需调用join()方法。

C++：

#include <iostream>
#include <thread>

void thread_function() {
    std::cout << "Hello, I am a new thread!" << std::endl;
}

int main() {
    std::thread t(thread_function);
    t.detach(); // 将线程t设置为分离状态
    return 0;
}

使用分离状态的线程可能会导致一定程度的不确定性，因为主线程（或其他线程）无法知道分离线程何时完成。因此，在使用线程分离时需要确保线程之间的同步和资源管理得当，避免竞态条件和内存泄漏等问题。

使用线程局部存储（Thread-Local Storage, TLS）

在某些编程语言和库中，可以使用线程局部存储（TLS）机制为每个线程分配独立的资源，如内存、文件描述符等。通过TLS，可以确保线程在退出时自动回收其占用的资源，从而简化线程管理和资源回收。需要注意的是，TLS机制通常需要特定的编程语言或库支持，如C++11的thread_local关键字、Python的threading.local()函数等。以下是使用线程局部存储的示例：

C++：

#include <iostream>
#include <thread>
#include <mutex>

thread_local int thread_local_variable; // 声明一个线程局部变量

void thread_function(int value) {
    thread_local_variable = value;
    std::cout << "Thread local variable: " << thread_local_variable << std::endl;
}

int main() {
    std::thread t1(thread_function, 10);
    std::thread t2(thread_function, 20);

    t1.join();
    t2.join();

    return 0;
}

Python：

import threading

thread_local_storage = threading.local()  # 创建一个线程局部存储对象

def thread_function(value):
    thread_local_storage.value = value
    print(f"Thread local variable: {thread_local_storage.value}")

t1 = threading.Thread(target=thread_function, args=(10,))
t2 = threading.Thread(target=thread_function, args=(20,))

t1.start()
t2.start()

t1.join()
t2.join()

4、进程终止方式？

进程终止是指一个进程完成其生命周期并释放其占用的资源的过程。操作系统和编程语言通常提供多种进程终止方式，以适应不同的场景和需求。以下是一些常见的进程终止方式：

正常终止（Normal Termination）：正常终止是指进程自然完成其执行任务并主动退出的情况。在这种情况下，进程通常会返回一个退出状态码（Exit Code），以表示执行结果。例如，在C和C++程序中，main()函数的返回值会作为进程的退出状态码。
异常终止（Abnormal Termination）：异常终止是指进程因某种错误或异常而被迫退出的情况。例如，进程遇到段错误（Segmentation Fault）、浮点异常（Floating Point Exception）或其他未捕获的异常时，操作系统通常会终止进程并生成一个核心转储文件（Core Dump）。异常终止通常表示进程存在bug或资源问题，需要进行调试和修复。
通过信号（Signal）终止：操作系统使用信号（Signal）机制来向进程发送事件和命令。部分信号可导致进程终止，如SIGTERM、SIGINT、SIGKILL等。例如，当用户按下Ctrl+C时，操作系统会向前台进程发送一个SIGINT信号，请求进程终止。进程可以捕获和处理部分信号（如SIGTERM、SIGINT），以实现优雅退出或其他自定义行为。然而，某些信号（如SIGKILL）无法被捕获，会强制终止进程。
通过系统调用（System Call）终止：操作系统通常提供一些系统调用来实现进程管理和控制。例如，在类Unix系统中，进程可以调用exit()、_exit()或abort()等系统调用来主动终止自己。这些系统调用会通知操作系统回收进程的资源，如内存、文件描述符等，并将进程状态设置为终止（Terminated）。
父进程终止子进程：父进程可以通过特定的系统调用或信号来终止其子进程。例如，在类Unix系统中，父进程可以调用kill()系统调用来向子进程发送SIGTERM、SIGINT、SIGKILL等信号，请求子进程终止。此外，父进程还可以使用wait()或waitpid()系统调用来等待子进程的完成，并在完成后回收资源。

5、讲一讲守护进程，僵尸进程，孤儿进程？

守护进程（Daemon）

定义

守护进程是一种在后台运行的特殊进程，通常用于提供某种服务或执行定期任务。守护进程没有控制终端（Controlling Terminal），因此不会与用户交互。它们通常在系统启动时启动，并在系统关闭时终止。

特点

脱离终端：不与用户终端（如 tty）关联，避免被终端信号（如 Ctrl+C）中断。
后台运行：以 root 权限或特定用户权限运行。
生命周期长：随系统启动而运行，直到系统关闭或被手动终止。

常见的守护进程

httpd：Web 服务器（如 Apache/Nginx）。
sshd：SSH 远程登录服务。
syslogd：系统日志服务。

在 Linux 中，创建守护进程的经典方法是通过两次 fork()：

#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>

void daemonize() {
    pid_t pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS); // 父进程退出
    
    // 子进程成为新会话的首进程（脱离终端）
    if (setsid() < 0) exit(EXIT_FAILURE);
    
    // 第二次 fork 确保进程无法重新获得终端控制权
    pid = fork();
    if (pid < 0) exit(EXIT_FAILURE);
    if (pid > 0) exit(EXIT_SUCCESS);
    
    // 关闭文件描述符，重定向标准输入/输出/错误
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    open("/dev/null", O_RDONLY);  // stdin → /dev/null
    open("/dev/null", O_RDWR);    // stdout → /dev/null
    open("/dev/null", O_RDWR);    // stderr → /dev/null
    
    // 设置工作目录和文件权限掩码
    chdir("/");
    umask(0);
}

僵尸进程（Zombie）

定义

僵尸进程是一种已结束运行但其退出状态还没有被父进程读取的进程。当一个进程终止时，其子进程的状态会变为僵尸进程，直到父进程通过调用 wait() 或 waitpid() 系统调用回收其资源。

产生原因

父进程未调用 wait() 或 waitpid() 回收子进程退出状态。
父进程忽略 SIGCHLD 信号（子进程终止时发送给父进程的信号）。

特点

无法被杀死：僵尸进程已经终止，无法通过 kill 命令终止。
占用资源：僵尸进程不再占用 CPU 或内存资源，但会占用进程表空间PCB。如果系统产生大量僵尸进程，可能导致进程表耗尽，从而影响系统性能。为避免僵尸进程，父进程应当及时回收已终止子进程的资源。
临时状态：若父进程退出，僵尸进程会被 init 进程（PID=1）接管并清理。

创建僵尸进程：

#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) {
        exit(0);    // 子进程立即退出
    } else {
        sleep(30);  // 父进程不调用 wait()
    }
    return 0;
}

查看僵尸进程：

#使用 ps 命令查看系统中的进程，僵尸进程的 STAT 列会显示为 Z。例如：
ps aux | grep Z

清除僵尸进程：

方法一：杀死父进程，让僵尸进程变成孤儿进程，由 init 进程收养并清理。

kill -9 父进程的PID

方法二：向父进程发送信号（如 SIGCHLD），通知父进程处理僵尸进程的状态。

#通知父进程重新获取僵尸进程的状态并完成清理。可以通过 kill 命令向父进程发送 SIGCHLD 信号，要求父进程解释其子进程的状态。
kill -s SIGCHLD 父进程的PID

孤儿进程（Orphan）

定义

孤儿进程是父进程已终止但仍在运行的子进程。孤儿进程会被 init 进程（PID=1）接管，init 进程会定期调用 wait() 或 waitpid() 系统调用，以回收孤儿进程的资源。因此，孤儿进程不会成为僵尸进程。

产生原因

父进程意外终止（如崩溃）。父进程未等待子进程而提前退出。

特点

总结

无害：由 init 进程负责回收资源，不会长期占用系统资源。
自动处理：操作系统通过 init 进程定期扫描并回收孤儿进程。
守护进程：后台运行的特殊进程，用于提供服务或执行定期任务，没有控制终端。
僵尸进程：已经终止但仍占用进程表空间的进程，需要父进程调用 wait() 或 waitpid() 回收资源。
孤儿进程：父进程在子进程之前终止的进程，会被 init 进程收养并最终得到妥善处理。

6、讲一讲父进程，子进程，进程组，会话？

进程是操作系统中正在运行的一个程序。每个进程都有其唯一标识符（PID），操作系统通过 PID 来调度和管理进程。

父进程（Parent Process）和子进程（Child Process）：在操作系统中，进程可以创建其他进程。创建新进程的进程称为父进程，新创建的进程称为子进程。这种关系形成了一个进程树结构，其中根进程（如 Unix 和类 Unix 系统中的 init 进程，进程ID为1）是所有其他进程的祖先。在 Unix 和类 Unix 系统中，可以通过 fork() 系统调用创建子进程。fork() 调用会复制当前进程的地址空间和环境，并创建一个新的进程。子进程从 fork() 调用处继续执行，并继承父进程的大部分属性（如文件描述符、环境变量等）。父子进程可以通过 getpid()（获取当前进程ID）和 getppid()（获取父进程ID）系统调用来识别彼此。

进程组（Process Group）：进程组是一个或多个进程的集合，它们共享相同的进程组ID（Process Group ID，简称PGID），通常进程组的 PGID 是进程组中第一个进程的 PID。进程组中的进程通常会共享某些属性，如它们对信号（如终端控制信号）的响应。进程组用于组织具有相关任务的进程，并允许向整个进程组发送信号。进程可以调用 setpgid() 系统调用加入一个现有的进程组，或创建一个新的进程组。

进程组的主要目的是为了方便管理一组相关的进程。例如，在一个终端中运行的多个命令，它们可以属于同一个进程组，这样可以方便地对这些进程进行统一的操作，如发送信号（如按下 Ctrl+C 会向进程组中的所有进程发送中断信号）。

会话（Session）：会话是一个或多个进程组的集合，它们共享相同的会话ID（Session ID，简称SID）。会话ID通常由会话中的第一个进程（会话组长）的进程ID决定。会话用于管理终端和登录环境下的进程。每个会话都有一个单独的控制终端（Controlling Terminal），该终端可以发送信号给会话中的所有进程。进程可以调用 setsid() 系统调用创建一个新的会话，并成为该会话的组长。

会话的概念通常用于终端管理。例如，当你登录到系统中打开一个终端窗口时，就会创建一个会话。在这个会话中，可以有多个进程组，每个进程组可以运行不同的程序。如果会话关闭（如用户退出登录或关闭终端窗口），会话中的所有进程都会被终止。

总结