进程与线程-----C语言经典题目（8）

一.什么是进程

定义：        

        进程指的是程序在操作系统内的一次执行过程。它不只是程序代码，还涵盖了程序运行时的各类资源与状态信息。包括创建、调度、消亡。

进程的状态（ps  -aux）：

        就绪状态：进程已经准备好运行，正在等待操作系统分配CPU资源。

        运行状态：进程正在CPU上执行。

        阻塞状态：进程因为等待某个事件（如I/O操作完成）而暂时无法继续执行。

        可唤醒等待态S：进程挂起等在某个资源到达后继续向下执行。

        不可唤醒等待态D：进程任务挂起直到等到某个信号来了才继续向下执行。

        暂停态T：进程任务挂起，直到CPU发送指令才能继续向下执行。

        僵尸态Z：代码已经执行完毕，空间仍然存在。

        结束态X：代码执行完毕，代码被回收。

用fork（）创建一个进程：

// 程序的主函数，程序的执行从这里开始
int main() 
{// 定义一个 pid_t 类型的变量 pid，用于存储 fork 函数的返回值pid_t pid;// 调用 fork 函数创建一个新的子进程// fork 函数会返回两次，在父进程中返回子进程的进程 ID，在子进程中返回 0，出错时返回 -1pid = fork();// 检查 fork 函数的返回值是否小于 0，如果小于 0 表示创建子进程时出错if (pid < 0) {// 使用 fprintf 函数向标准错误输出流输出错误信息，提示 fork 操作失败fprintf(stderr, "Fork failed\n");// 返回 1 表示程序异常退出return 1;} // 检查 fork 函数的返回值是否等于 0，如果等于 0 表示当前代码在子进程中执行else if (pid == 0) {// 输出提示信息，表明当前是子进程，并使用 getpid 函数获取当前子进程的进程 ID 并打印printf("This is the child process, pid = %d\n", getpid());} // 如果 fork 函数的返回值大于 0，说明当前代码在父进程中执行，返回值即为子进程的进程 IDelse {// 输出提示信息，表明当前是父进程，并打印子进程的进程 IDprintf("This is the parent process, child pid = %d\n", pid);}// 程序正常结束，返回 0return 0;
}

二.在linux系统中使用什么结构表示一个进程？

        用task_struct结构体来表示一个进程。这个结构体在linux内核里定义，包含了进程的所有信息，像进程状态、进程ID、优先级、打开的文件等。

        task_struct源于linux内核源码中的include/linux/sched.h文件。

        里面的volatile long state ，原来表示进程的当前状态。

        pid_t  pid ：进程的 唯一标识符。

        struct task_struct *parent  ：指向父进程的指针。

        struct list_head children ：子进程链表。

三.系统通过什么区分两个正在运行的a.out？

        C语言系统本身并不会区分a.out这个特定的执行文件，而是去区分运行着的进程。

1.进程ID（PID）

        每个进程都有独一无二的进程ID（PID）。当启动一个a.out 程序时，操作系统会给它分配一个PID，PID是一个正整数，在系统里是唯一的，操作系统能够借助PID来区分不同的进程。

        可以通过getpid（）函数获取当前进程的PID。

2.进程控制块（PCB）

        操作系统为每个进程都维护了一个进程控制块（PCB），它是一个数据结构，里面包含了进程的各种信息，像PID、进程状态、程序计数器、内存指针、文件描述符等。操作系统会依据PCB来管理和区分不同的进程。

3.父进程ID（PPID）

        每个进程都有一个父进程，父进程ID（PPID）同样能用来区分进程。可以用getppid（）函数获取当前进程的父进程ID。

4.命令行参数和环境变量

        即使是同一个可执行文件a.out ,要是在启动时使用了不同的命令行参数或者环境变量，操作系统也能把他们区分开来。

四.当一个进程开始运行，系统（32bit）给用户层分配的内存空间是多大，有哪些区域。每个区域存储什么东西？

        32bit 的系统中，给用户层分配的内存空间通常为4GB，

代码段：

        存储内容：存放程序的可执行指令，也就是编译后的机器码。

        特性：只读，为了防止程序在运行过程中意外修改自身的指令。

                   共享，当多个进程运行同一个程序时，这些进程可以共享这一个代码段。

数据段：

        存储内容：存储已初始化的全局变量和静态变量，这些变量的值非0。

        例如：int  a  =  10；

BSS段：

        存储内容：未初始化的全局变量和静态变量会被存放在BSS段中，在程序开始执行前，系统会自动把这些变量初始化为0。

        例如：int  a  ；

堆：

        存储内容：动态分配的内存就存放在堆中，如使用malloc、calloc、realloc。

        特性：堆的内存分配是由低地址向高地址增长的，且使用完后需要通过free（）来释放内存，否则会造成内存泄漏。

栈：

        存储内容：函数调用的上下文，也就是栈帧，存放在栈中。栈帧里包含局部变量、函数参数以及返回地址等信息。

        特性：栈的内存分配是从高地址向低地址增长的，它的空间大小是有限的，一旦超出限制就会导致栈溢出。

命令行参数和环境变量：

        存储内容：程序运行时的命令行参数以及环境变量存放在这个区域。        

        位置：位于用户空间的最高地址处。

高地址┌─────────────────────────────────────┐│                                     ││     环境变量和命令行参数             ││                                     │├─────────────────────────────────────┤│                                     ││             栈                       ││      （向低地址方向增长）           ││                                     │├─────────────────────────────────────┤│                                     ││             堆                       ││      （向高地址方向增长）           ││                                     │├─────────────────────────────────────┤│                                     ││           BSS段                     ││      （未初始化的全局变量）         ││                                     │├─────────────────────────────────────┤│                                     ││           数据段                    ││      （已初始化的全局变量）         ││                                     │├─────────────────────────────────────┤│                                     ││           代码段                    ││      （程序指令）                   ││                                     │└─────────────────────────────────────┘
低地址

五.什么是虚拟地址？

        虚拟地址是运行程序时 CPU 所生成的地址。

主要功能：

        内存隔离：不同进程的虚拟地址空间相互独立，这样一个进程出现问题，不会对其他进程造成影响。

        内存抽象化：程序所使用的内存空间是连续的，然而物理内存可能是分散的。

        内存保护：通过设置访问权限，能够防止程序对其他进程的内存进行越界访问。

        内存共享：不同进程可以共享同一块物理内存，例如共享库。

相关 c 语言代码：

        指针实际上就是虚拟地址：

int a = 10;
int *p = &a; // p存储的是变量a的虚拟地址

六.进程的作用是什么？

1.资源分配的基本单位：

        系统会给每个进程分配独立的系统资源，像内存空间、文件描述符、CPU 时间片等。

int main() 
{// 每个进程都有自己独立的内存空间int pid = fork(); // 创建子进程if (pid == 0) {// 子进程printf("子进程: PID=%d\n", getpid());} else {// 父进程printf("父进程: PID=%d\n", getpid());}return 0;
}

2.实现多任务处理：

        借助进程，系统可以同时运行多个程序，也就是实现并发或并行操作。

int main() 
{pid_t pid = fork(); // 创建子进程if (pid < 0) {perror("创建进程失败");exit(EXIT_FAILURE);}if (pid == 0) {// 子进程执行新程序execlp("/bin/ls", "ls", "-l", NULL);} else {// 父进程继续执行其他任务printf("父进程继续运行...\n");wait(NULL); // 等待子进程结束}return 0;
}

3.提供隔离环境：

        各个进程之间相互隔离，一个进程出现崩溃或者异常，通常不会对其他进程造成影响。

int main() 
{pid_t pid = fork();if (pid == 0) {// 子进程故意出错printf("子进程准备崩溃...\n");*((int*)0) = 10; // 访问无效地址，引发段错误} else {// 父进程不受影响printf("父进程继续正常运行\n");sleep(2);}return 0;
}

4.实现程序的并发执行

        在处理 I/O 密集型或者计算密集型任务时，通过创建多个进程，可以显著提高程序的执行效率

#define N 5int main() 
{int i = 0；for (i = 0; i < N; i++) {pid_t pid = fork();if (pid == 0) {printf("子进程 %d 执行计算任务\n", i);exit(EXIT_SUCCESS);}}// 父进程等待所有子进程结束for (i = 0; i < N; i++) {wait(NULL);}printf("所有子进程执行完毕\n");return 0;
}

5.实现跨进程通信（IPC）

        不同进程之间可以通过管道、消息队列、共享内存等机制进行通信，从而实现更复杂的分布式系统。

int main() 
{int pipefd[2];      // 创建管道文件描述符数组：pipefd[0]为读端，pipefd[1]为写端char buffer[100];   // 用于存储从管道读取的数据的缓冲区// 创建匿名管道，失败时返回-1并设置errnoif (pipe(pipefd) == -1) {perror("创建管道失败");  // 输出系统错误信息return 1;               // 非零返回值表示程序异常退出}pid_t pid = fork();         // 创建子进程，返回值：子进程返回0，父进程返回子进程PIDif (pid == 0) {// 子进程执行区域close(pipefd[0]);       // 关闭不需要的读端，避免资源泄漏const char* message = "Hello from child process!";// 向管道写端写入字符串（包含字符串结束符'\0'）write(pipefd[1], message, strlen(message) + 1);close(pipefd[1]);       // 写入完成后关闭写端，通知读端数据已写完} else {// 父进程执行区域close(pipefd[1]);       // 关闭不需要的写端// 从管道读端读取数据到缓冲区，最多读取sizeof(buffer)-1字节read(pipefd[0], buffer, sizeof(buffer));printf("父进程收到消息: %s\n", buffer);  // 输出从子进程接收的消息close(pipefd[0]);       // 读取完成后关闭读端}return 0;                   // 程序正常退出
}

七.进程的状态有哪些？

运行态：

        进程正在 CPU 上执行指令。在单 CPU 系统中，同一时刻只有一个进程处于运行态

就绪态：

        进程已获得除了 CPU 外的所有必要资源，等待操作系统调度执行，一旦 CPU 空闲，就绪队列中的进程将被选中进入运行态。

阻塞态：

        进程因等待某个事件（如 I/O 完成、信号量、锁等）而暂停执行。此时进程不占用 CPU 资源，直到等待的事件发生后，进程才会转为就绪态。

新建态：

        进程刚刚被创建，但尚未被操作系统完全初始化。此时进程正在分配资源并进入系统。

终止态：

        进程已执行完毕或被强制终止，但尚未完全释放资源。在终止态下，进程仍保留一些信息（如退出状态码）供父进程查询，之后才会被系统彻底销毁。

挂起态：

        进程暂时被移除内存，存储到磁盘上。挂起态通常分为 就绪挂起（进程在磁盘上就绪，等待被调回内存）和阻塞挂起（进程在磁盘上等待事件）。这种状态常见于内存紧张的系统中。

查看进程状态：

        ps命令：查看进程的当前状态（R 表示运行，S 表示睡眠，D 表示不可中断睡眠，T 表示停止，Z 表示僵尸进程）。

        /proc/[pid]/status 文件：包含进程的详细状态信息。

        系统调用：如wait（）、waitpid() 获取子进程的终止状态。

八.进程相关命令有哪些？分别干什么的？

1.fork（）

        这个系统调用的作用是创建一个子进程，新创建的子进程几乎是父进程的副本。

        子进程会获取父进程的数据空间、堆和栈的拷贝。

        返回值：在父进程中返回子进程的 PID（进程ID），在子进程中返回0，如果返回-1，就表明创建进程失败。

int main() 
{pid_t pid = fork();if (pid < 0) {perror("fork failed");return 1;}else if (pid == 0) {printf("子进程: PID = %d\n", getpid());} else {printf("父进程: 子进程PID = %d, 父进程PID = %d\n", pid, getpid());}return 0;
}

2.vfork（）

        vfork（）也是创建子进程，但与fork（）有区别，vfork（）创建的子进程会和父进程共享地址空间，而且在子进程调用exec（）或者exit（）之前，父进程会被阻塞。

3.exec（）系列函数

        这一系列函数的作用是用新的程序替换当前进程的映像。即当调用exec（）之后，当前进程的代码段、数据段和堆栈都会被新程序替换。

        常见的有：execl（），execv（），execle()，

4.wait（）和waitpid（）

        主要用于父进程等待子进程结束，并且可以获取子进程的终止状态。

        wait（&status）：父进程会阻塞，直到任意一个子进程终止。

        waitpid（pid，&status，options）：父进程等待特定 PID 的子进程，或者通过选项设置为非阻塞模式。

5.getpid（）和getppid（）

        getpid（）：返回当前进程的 PID。

        getppid（）：返回当前进程父进程的 PID。

6.exit（）和 _exit（）

        用于终止当前进程。

        exit（status）：会刷新一下缓冲区，然后终止进程。

        _exit（status）：直接终止进程。

7.system（）

        作用是执行一个 shell 命令。它会创建一个子进程来执行指定的命令，父进程会等待子进程结束。

int main()
{system("ls -l");  // 执行ls -l命令return 0;
}

8.kill（）

        用于向进程发送信号，如终止进程、暂停进程等。

9.signal（）和sigaction（）

        用于处理信号。

10.setsid（）        

        用于创建一个新的会话。

九.通过哪个函数新建进程，函数返回值的含义，父子进程关系？

        用fork（）函数即可创建新进程。

1.函数原型与头文件

#include <unistd.h>
pid_t fork(void);

2.返回值的含义

        负值：表面进程创建失败，可能是系统资源不足，或者进程数量达到了上限。

        零：这是子进程的返回结果，子进程可以通过getppid（）来获取父进程的 ID。

        正整数：这是父进程的返回结果，返回的数值是新创建的子进程的 ID。

3.父子进程之间的关系

        相同点：

                子进程会复制父进程的代码段、数据段、堆和栈等内存空间。

                子进程会继承父进程的文件描述符、信号处理方式以及当前工作目录。

        不同点：

                进程 ID（PID）不一样，子进程的 PID 是唯一的。

                父进程 ID（PPID）不同，子进程的 PPID 是创建它的父进程的 PID。

                子进程的计时器会重新开始计时。

4.执行流程

        调用fork（）之后，父子进程会并发执行，但执行顺序由操作系统调度器决定。

        子进程从fork（）返回处开始执行。

int main() 
{pid_t pid = fork();if (pid < 0) {perror("fork failed");return 1;} else if (pid == 0) {// 子进程执行的代码printf("子进程: PID = %d, PPID = %d\n", getpid(), getppid());} else {// 父进程执行的代码printf("父进程: PID = %d, 子进程PID = %d\n", getpid(), pid());}return 0;
}

10.进程退出后，需要注意什么。如何避免僵尸进程的产生？

        主要要避免僵尸进程的出现。

僵尸进程的形成：

        当子进程终止时，它的进程描述符不会立刻被释放，而是会保留下来，直至父进程读取到子进程的退出状态信息。要是父进程没有调用wait（）或waitpid（）来获取子进程的状态，子进程就会变成僵尸进程。

僵尸进程的坏处：

        尽管僵尸进程不会占用太多系统资源，但如果这类进程数量过多，就可能导致系统的进程表被占满，使得新进程无法创建。

资源释放状况：

        子进程终止后，它所占用的大部分资源，像内存、文件描述符等，都会被系统回收。

        但进程描述符依然会保留，直到父进程处理完相关状态。

如何避免：

        1.父进程主动等待子进程结束：

                父进程可以通过调用wait（）或waitpid（）来获取子进程的退出状态，从而让子进程的资源得到释放。

int main() 
{pid_t pid = fork();if (pid < 0) {perror("Fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process (PID=%d) exiting...\n", getpid());exit(EXIT_SUCCESS);} else {// 父进程printf("Parent process (PID=%d) waiting...\n", getpid());int status;wait(&status); // 等待子进程结束printf("Child process exited with status %d\n", WEXITSTATUS(status));}return 0;
}

        2.父进程忽略子进程的退出信号

                父进程可以通过设置 SIGCHLD 信号的处理方式为SIG_IGN，让内核自动清理子进程。这样就无需父进程调用wait（）了。

int main() 
{// 设置忽略 SIGCHLD 信号，让内核自动清理子进程signal(SIGCHLD, SIG_IGN);pid_t pid = fork();if (pid < 0) {perror("Fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process (PID=%d) exiting...\n", getpid());exit(EXIT_SUCCESS);} else {// 父进程可以继续执行其他任务，无需等待子进程printf("Parent process (PID=%d) continuing...\n", getpid());sleep(2);}return 0;
}

        3.采用非阻塞方式检查子进程状态

                父进程可以使用waitpid（）并传入 WNOHANG 参数，以非阻塞的方式查询子进程是否已经终止。

int main() 
{pid_t pid = fork();if (pid < 0) {perror("Fork failed");return 1;} else if (pid == 0) {// 子进程printf("Child process (PID=%d) sleeping...\n", getpid());sleep(2);printf("Child process exiting...\n", getpid());exit(EXIT_SUCCESS);} else {// 父进程printf("Parent process (PID=%d) working...\n", getpid());int status;pid_t result;// 循环检查子进程状态，不阻塞父进程while ((result = waitpid(pid, &status, WNOHANG)) == 0) {printf("Parent: Child is still running...\n");sleep(1);}if (result == pid) {printf("Parent: Child exited with status %d\n", WEXITSTATUS(status));}}return 0;
}

十一.在子进程中需要执行一个外部可执行程序需要怎么做。与原来子进程相比发生什么变化？

        需要用到exec系列函数。

执行外部程序方法

        1.运用fork（）函数创建出子进程。

        2.在子进程中调用exec系列函数，像execl  、execv、execle、execve、execlp、execvp

int main() 
{pid_t pid = fork();  if (pid < 0) {perror("fork失败");  // 输出错误信息exit(EXIT_FAILURE);  // 终止程序} else if (pid == 0) {// 子进程执行区域printf("子进程开始执行外部程序...\n");// 调用execl执行/bin/ls命令// 参数1：可执行文件路径// 参数2：命令名（argv[0]）// 参数3及后续：命令行参数（以NULL结尾）execl("/bin/ls", "ls", "-l", NULL);// 若execl返回，说明调用失败perror("execl失败");  // 输出错误原因exit(EXIT_FAILURE);  // 子进程异常退出} else {// 父进程执行区域printf("父进程等待子进程结束...\n");// 等待子进程终止// wait(NULL)会阻塞父进程直到任意子进程结束wait(NULL);  printf("子进程已结束\n");}return 0;
}

子进程发生的变化

1.全新的程序映像

        子进程原本的程序代码会被外部程序的代码所取代，而且程序的全局变量也会被重置。

2.新的进程上下文

        子进程会拥有新的程序计数器、堆栈指针以及寄存器值。

3.文件描述符保留

        子进程在调用exec之前打开的文件描述符，在exec调用之后依然会保持打开状态，除非这些文件描述符设置了 FD_CLOEXEC 标志

4.进程 ID 保持不变

        子进程的 PID 不会改变，只是运行的程序发生了变化

5.内存空间重置

        子进程原来的内存内容会被丢弃，转而加载新程序的内存映像。

十二.什么是线程？

        线程属于程序能够独立运行的最小执行单元。存在于进程内部，和同一进程的其他线程共享全局变量、文件描述符等资源，不过各自拥有独立的栈空间与程序计数器。

线程的特点

        轻量级：线程的创建和切换开销比进程小，因为他们共享进程的资源。

        资源共享：同一进程内的线程共享内存空间、文件句柄等资源，便于数据交换和通信。

        并发执行：多个线程可以并发执行，提高程序和执行效率。

        独立执行流程：每个线程有自己的执行路径和状态。

线程基本操作：

        通常通过 POSIX 线程库来实现多线程。

// 线程函数，线程启动后会执行这个函数
void* thread_function(void* arg) 
{int thread_id = *(int*)arg;printf("线程 %d 正在运行\n", thread_id);// 线程执行一些工作...pthread_exit(NULL); // 线程退出
}int main() 
{pthread_t thread1, thread2;int id1 = 1, id2 = 2;// 创建两个线程if (pthread_create(&thread1, NULL, thread_function, &id1) != 0) {perror("线程创建失败");return 1;}if (pthread_create(&thread2, NULL, thread_function, &id2) != 0) {perror("线程创建失败");return 1;}// 等待线程结束if (pthread_join(thread1, NULL) != 0) {perror("等待线程失败");return 1;}if (pthread_join(thread2, NULL) != 0) {perror("等待线程失败");return 1;}printf("所有线程已完成\n");return 0;
}

编译时需要链接 pthread 库 ：-lpthread

线程同步：

        由于多线程共享资源，可能会引发竟态条件。需要使用同步机制，如互斥锁、信号量等。

使用互斥锁：

        

int shared_counter = 0;
pthread_mutex_t mutex;void* increment(void* arg) 
{int i = 0；for (i = 0; i < 100000; i++) {pthread_mutex_lock(&mutex);  // 加锁shared_counter++;pthread_mutex_unlock(&mutex); // 解锁}pthread_exit(NULL);
}int main() 
{pthread_t t1, t2;pthread_mutex_init(&mutex, NULL); // 初始化互斥锁pthread_create(&t1, NULL, increment, NULL);pthread_create(&t2, NULL, increment, NULL);pthread_join(t1, NULL);pthread_join(t2, NULL);pthread_mutex_destroy(&mutex); // 销毁互斥锁printf("共享计数器的值: %d\n", shared_counter);return 0;
}

十三.进程和线程的区别？

本质差异：

        进程：是程序在操作系统中的一次执行实例，是系统进行资源分配和调度的基本单位。

        线程：是进程中的一个执行单元，是 CPU 调度和分派的基本单位。

内存空间：

        进程：不同进程之间的内存空间是相互独立的，一个进程不能直接访问另一个进程的内存。

        线程：同一进程内的线程共享进程的内存空间，他们可以直接访问进程中的全局变量和堆内存。

创建开销：

        进程：创建进程时，操作系统需要为其分配独立的内存空间和系统资源，开销比较大。

        线程：创建线程时，由于共享进程的资源，只需要为线程分配栈空间和程序计数器等少量资源，开销比较小。

通信方式：

        进程：进程间通信（IPC）需要使用特定的机制，如管道、消息队列、共享内存、套接字等。

        线程：线程间通信可以直接通过共享全局变量来实现。这种方式简单高效。但要注意线程同步的问题，避免竟态条件。

调度和切换：

        进程：进程的调度和切换需要保存和恢复进程的上下文，开销比较大。

        线程：线程的调度和切换只需要保存和恢复线程的上下文，开销比较小。

健壮性：

        进程：一个进程崩溃不会影响其他进程，因为他们的内存空间是独立的。

        线程：一个线程崩溃可能会导致整个进程崩溃，因为他们是共享同一内存空间。

// 线程函数
void* thread_function(void* arg) 
{printf("这是一个线程，线程ID: %lu\n", pthread_self());return NULL;
}int main() 
{// 创建进程pid_t pid = fork();if (pid < 0) {// 出错处理perror("fork失败");exit(EXIT_FAILURE);} else if (pid == 0) {// 子进程printf("这是子进程，进程ID: %d\n", getpid());} else {// 父进程printf("这是父进程，进程ID: %d，子进程ID: %d\n", getpid(), pid);// 创建线程pthread_t thread_id;int result = pthread_create(&thread_id, NULL, thread_function, NULL);if (result != 0) {// 出错处理perror("线程创建失败");exit(EXIT_FAILURE);}// 等待线程结束pthread_join(thread_id, NULL);printf("线程已结束\n");}return 0;
}