操作系统高频总结三

发表于 2025/01/14 更新于 2025/01/14

作者 匆匆那年 37 分钟阅读

分段和分页的区别

分段（Segmentation） 和 分页（Paging） 是两种内存管理技术，主要用于操作系统中的虚拟内存管理。二者有不同的设计理念、实现方式和应用场景，下面是它们的详细对比：

1. 基本概念

分段（Segmentation）

将内存划分为逻辑上有意义的段（Segment）。
每个段对应不同的功能模块，例如代码段、数据段、栈段等。
每个段的大小可以动态调整，不固定。

分页（Paging）

将内存划分为固定大小的页（Page），逻辑上和物理上都以页为单位进行管理。
页的大小通常是固定的（如 4KB、8KB）。
页与页之间没有逻辑上的联系。

2. 划分方式

特性	分段（Segmentation）	分页（Paging）
划分依据	按程序的逻辑功能划分（如代码段、数据段、栈段）。	按固定大小的物理单位划分（页）。
段/页大小	不固定，由程序需求决定。	固定大小（如 4KB）。
地址结构	段基址 + 偏移量。	页号 + 页内偏移量。

3. 地址转换

分段

虚拟地址分为两部分：
- 段号（Segment Number）。
- 段内偏移量（Offset）。
使用段表（Segment Table）：
- 根据段号查找段表，获取段的基址。
- 将基址加上偏移量，得到物理地址。

公式： $\text{物理地址} = \text{段基址} + \text{偏移量}$

分页

虚拟地址分为两部分：
- 页号（Page Number）。
- 页内偏移量（Offset）。
使用页表（Page Table）：
- 根据页号查找页表，获取物理内存中的页框（Frame）号。
- 将页框号与偏移量组合，得到物理地址。

公式： $\text{物理地址} = \text{页框号} \times \text{页大小} + \text{偏移量}$

4. 优缺点对比

特性	分段（Segmentation）	分页（Paging）
内存利用率	段的大小可以动态调整，减少外部碎片，但可能有内部碎片。	页大小固定，避免外部碎片，但可能有少量内部碎片。
地址空间	根据程序逻辑分段，更接近程序设计的逻辑模型。	均匀划分，适合现代计算机体系结构。
灵活性	每段可以根据需要独立增长或收缩，灵活性高。	页大小固定，不灵活。
实现复杂度	地址转换复杂，段表需要存储段的基址和长度等信息。	地址转换简单，页表只需存储页框号。
内存碎片	容易产生外部碎片（段大小不一）。	只会产生少量内部碎片（页尾剩余部分）。
性能	地址转换稍慢，需查段表并计算基址加偏移量。	地址转换速度较快（固定大小页）。

5. 应用场景

分段的应用场景

需要逻辑分隔：
- 程序设计中需要按功能模块划分，如代码段、数据段、栈段等。
内存需求多样化：
- 段大小可变，适合动态需求的应用。

分页的应用场景

现代操作系统：
- 几乎所有现代操作系统（如 Linux、Windows）都使用分页管理内存。
虚拟内存管理：
- 分页可以方便地实现虚拟内存，支持页面置换。

6. 分段与分页的结合

一些现代操作系统结合了分段和分页的优点：

分段-分页结合的内存管理

先将程序分为多个段，每个段再分页管理。
逻辑上按段划分，物理上按页划分。

优点：

兼具分段的逻辑灵活性和分页的物理内存管理效率。

实例：

x86 架构中的内存管理结合了分段和分页：
- 分段用于提供多任务环境下的内存隔离。
- 分页用于实现虚拟内存和提高内存利用率。

7. 总结表格

特性	分段（Segmentation）	分页（Paging）
划分依据	按程序逻辑划分（代码段、数据段）。	按固定大小的页划分。
段/页大小	动态，可变大小。	固定大小（如 4KB）。
地址转换	段号 + 偏移量 -> 段表查找。	页号 + 页内偏移 -> 页表查找。
内存碎片	外部碎片明显，但无内部碎片。	无外部碎片，但有少量内部碎片。
灵活性	灵活，适合复杂内存需求。	简单，适合现代计算机架构。
典型应用	早期系统的内存分段。	现代操作系统中的虚拟内存管理。

分段更强调逻辑意义，而分页更注重物理实现效率。在现代系统中，分页通常占主导地位，结合分段可实现更高效的内存管理。

进程间通信原理和方式

进程间通信（Inter-Process Communication, IPC） 是指在操作系统中，运行在不同地址空间的进程之间进行数据交换或协调的机制。由于进程彼此独立且地址空间相互隔离，需要特定的通信机制来实现信息共享或同步。

进程间通信的原理

地址空间隔离：
- 每个进程有独立的虚拟地址空间，不能直接访问其他进程的内存。
- 操作系统通过提供通信机制在进程之间传递数据。
操作系统内核参与：
- IPC 机制通常需要操作系统内核的支持，例如通过内核缓冲区或文件系统实现。
通信方式的分类：
- 共享内存：多个进程共享一段物理内存，通过同步机制避免冲突。
- 消息传递：进程通过操作系统发送和接收消息，数据经过内核缓冲区。
- 信号机制：用于发送简单的通知。

进程间通信的常见方式

1. 管道（Pipe）

特点

单向通信（匿名管道）。
只能在父子进程之间使用。
数据以 FIFO（先进先出）方式传递。

扩展

命名管道（Named Pipe, FIFO）：
- 支持双向通信。
- 可以在不相关的进程之间使用。

代码示例

  
#include <iostream>
#include <unistd.h> // For pipe

int main() {
    int fd[2]; // 文件描述符数组
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    pid_t pid = fork();
    if (pid == 0) { // 子进程
        close(fd[0]); // 关闭读端
        write(fd[1], "Hello, parent!", 15);
        close(fd[1]);
    } else { // 父进程
        close(fd[1]); // 关闭写端
        char buffer[20];
        read(fd[0], buffer, 15);
        std::cout << "Parent received: " << buffer << std::endl;
        close(fd[0]);
    }
    return 0;
}

2. 消息队列（Message Queue）

特点

通过操作系统维护的队列进行消息传递。
支持多种优先级，可以有序处理消息。

优点

支持任意大小的数据传输。
可以在无关系的进程间通信。

示例（POSIX 消息队列）

  
#include <iostream>
#include <mqueue.h>
#include <cstring>

int main() {
    const char* queue_name = "/test_queue";
    mqd_t mq = mq_open(queue_name, O_CREAT | O_RDWR, 0666, NULL);
    if (mq == -1) {
        perror("mq_open");
        return 1;
    }

    const char* message = "Hello, Message Queue!";
    mq_send(mq, message, strlen(message), 0);

    char buffer[256];
    mq_receive(mq, buffer, sizeof(buffer), NULL);
    std::cout << "Received: " << buffer << std::endl;

    mq_close(mq);
    mq_unlink(queue_name);
    return 0;
}

3. 共享内存（Shared Memory）

特点

多个进程共享一段物理内存，效率最高。
需要同步机制（如信号量、互斥锁）来保证访问的安全性。

优点

速度快，适合大数据量传输。
不需要数据复制。

示例（POSIX 共享内存）

  
#include <iostream>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    const char* shm_name = "/test_shm";
    int shm_fd = shm_open(shm_name, O_CREAT | O_RDWR, 0666);
    ftruncate(shm_fd, 256); // 设置共享内存大小

    char* shm_ptr = (char*)mmap(0, 256, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
    strcpy(shm_ptr, "Hello, Shared Memory!");

    munmap(shm_ptr, 256);
    shm_unlink(shm_name);
    return 0;
}

4. 信号（Signal）

特点

用于发送简单的通知，信号本身不携带复杂信息。
常用于进程间的事件通知或控制。

示例

  
#include <iostream>
#include <csignal>
#include <unistd.h>

void signalHandler(int signum) {
    std::cout << "Received signal: " << signum << std::endl;
}

int main() {
    signal(SIGUSR1, signalHandler);
    if (fork() == 0) { // 子进程
        kill(getppid(), SIGUSR1); // 发送信号给父进程
    } else { // 父进程
        pause(); // 等待信号
    }
    return 0;
}

5. 套接字（Socket）

特点

支持本地进程通信（Unix Domain Socket）和跨网络通信（TCP/IP）。
功能强大，适合复杂场景。

示例

  
#include <iostream>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>

int main() {
    const char* socket_path = "/tmp/test_socket";
    int server_fd = socket(AF_UNIX, SOCK_STREAM, 0);

    sockaddr_un addr;
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, socket_path);
    bind(server_fd, (sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 1);

    int client_fd = accept(server_fd, nullptr, nullptr);
    char buffer[128];
    read(client_fd, buffer, sizeof(buffer));
    std::cout << "Received: " << buffer << std::endl;

    close(client_fd);
    close(server_fd);
    unlink(socket_path);
    return 0;
}

6. 信号量（Semaphore）

特点

用于进程间的同步，通常结合共享内存使用。
可以控制资源的访问数量。

总结对比

通信方式	优点	缺点	适用场景
管道（Pipe）	简单易用，数据流式传输。	仅支持父子进程间通信，单向。	简单的线性数据流传输。
消息队列	灵活，支持消息优先级。	数据拷贝开销大。	不相关进程的中等数据量传输。
共享内存	高效，适合大数据量传输。	需要同步机制，管理复杂。	大量数据的快速传输。
信号（Signal）	快速，轻量级。	只能传递简单通知，不适合复杂数据。	简单事件通知。
套接字（Socket）	强大，支持本地和远程通信。	编程复杂，性能略低。	复杂通信需求，本地或网络通信。
信号量（Semaphore）	精确控制资源访问。	仅用于同步，不传递数据。	多进程同步，配合共享内存使用。

根据具体需求选择合适的 IPC 方式，可以有效提升程序的性能和灵活性。

fock()读时共享写时拷贝

在 Unix 系统中，fork() 是用来创建子进程的系统调用。当一个进程调用 fork() 时，操作系统会复制当前进程（父进程）的所有资源（如地址空间、文件描述符等）来生成一个子进程。

为了提高效率并节约内存，操作系统采用了 读时共享、写时拷贝（Copy-On-Write, COW） 的技术。

1. 什么是读时共享，写时拷贝？

读时共享：
- 父进程和子进程在 fork() 后，共享同一块内存，这块内存是只读的。
- 只要父子进程没有试图修改内存中的数据，就不会发生实际的内存复制。
- 共享减少了不必要的内存拷贝，提高了效率。
写时拷贝：
- 如果父进程或子进程试图修改这块共享内存，操作系统会为要修改的数据块 分配新的内存空间，然后将原数据复制到新内存中。
- 修改只会影响新分配的内存，确保父进程和子进程的内存数据相互独立。

2. 为什么需要写时拷贝？

性能优化：
- 如果 fork() 后父进程或子进程只是执行读取操作，而不修改内存数据，就无需复制整个内存空间。
- 对于大进程来说，减少了大量内存的拷贝操作，提高了效率。
节省内存：
- 父子进程共享未修改的内存数据，避免了重复占用物理内存。
分离操作：
- 写时拷贝确保修改操作不会影响其他进程的数据，满足进程隔离的需求。

3. 工作原理

(1) `fork()` 的执行过程

调用 fork()时：
1. 操作系统为子进程创建一个新的进程控制块（PCB）。
2. 子进程继承父进程的资源（文件描述符、内存映射等）。
3. 对内存，父进程和子进程的页表条目指向同一块物理内存，且将内存页标记为只读。
4. 返回到父进程和子进程，分别从 fork() 调用点继续执行。

(2) 写操作触发 COW

当父进程或子进程尝试写入内存时：
1. 发生 页面异常（Page Fault），内存管理单元（MMU）检测到目标内存页是只读的。
2. 操作系统会分配一块新的物理内存。
3. 将原内存的数据复制到新内存。
4. 更新进程的页表条目，使其指向新分配的物理内存。
5. 完成写操作。

4. 示例代码分析

(1) 示例代码

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

int main() {
    char* shared_memory = (char*)malloc(100); // 动态分配内存
    strcpy(shared_memory, "Original Data");

    pid_t pid = fork();
    if (pid == 0) {
        // 子进程
        printf("Child reads: %s\n", shared_memory);
        strcpy(shared_memory, "Child Modified");
        printf("Child writes: %s\n", shared_memory);
    } else {
        // 父进程
        sleep(1); // 确保子进程先运行
        printf("Parent reads: %s\n", shared_memory);
    }

    free(shared_memory);
    return 0;
}

(2) 运行结果

可能的输出：

Child reads: Original Data
Child writes: Child Modified
Parent reads: Original Data

(3) 分析

fork() 后，父子进程共享 shared_memory 的内存。
子进程在修改数据时触发
写时拷贝：
- 操作系统为子进程分配新内存，并将原数据复制到新内存。
- 子进程的写操作仅修改它的新内存。
父进程读取的仍是原来的数据，因为它的内存映射未受影响。

5. 优点与缺点

优点

高效：
- 避免不必要的内存复制，提高了 fork() 的性能。
节省内存：
- 父子进程共享未修改的内存页，降低了物理内存的使用量。

缺点

复杂性：
- 写时拷贝需要额外的内存页分配和数据复制操作，增加了系统复杂度。
延迟：
- 第一次写操作会触发 COW，增加了额外的开销。

6. 使用场景与优化

(1) 使用场景

进程创建后立即执行 exec()：
- 如果子进程在创建后立即调用 exec() 替换地址空间，写时拷贝的优化无意义。
- 使用 vfork() 可以避免内存页表复制。
频繁创建子进程：
- 数据较大但大部分为只读时，COW 提供了显著的性能优化。

(2) 优化建议

使用 mmap() 的共享内存：
- 如果父子进程需要共享数据，可以使用 mmap() 映射共享内存，而非通过 COW。
限制共享内存的写入：
- 尽量减少父子进程对共享内存的写操作。
使用多线程代替多进程：
- 多线程共享整个进程的地址空间，避免 COW 的额外开销。

7. 总结

读时共享写时拷贝 是 fork() 的核心优化机制，用于减少内存复制的开销。
它通过共享未修改的内存页实现高效的内存管理，只有在需要修改时才进行数据的实际复制。
写时拷贝适合读多写少的场景，在需要频繁写入时应考虑其他优化方式，如共享内存或线程模型。

互斥锁+条件变量

互斥锁 和 条件变量 是多线程编程中常用的同步机制，用于管理共享资源的访问和线程之间的通信。两者经常配合使用，实现线程的协调与同步。

1. 互斥锁与条件变量的作用

互斥锁（Mutex）

作用：
- 用于保护临界区，确保同一时刻只有一个线程能够访问共享资源。
- 防止多个线程同时修改共享资源，造成数据不一致。
原理：
- 通过加锁（lock）和解锁（unlock）机制控制对共享资源的访问。

条件变量（Condition Variable）

作用：
- 用于线程之间的等待与通知，协调线程的执行顺序。
- 让一个线程等待某个条件满足后继续执行，避免忙等待。
原理：
- 线程调用 wait 进入等待状态，直到其他线程通过 notify_one 或 notify_all 唤醒它。

2. 条件变量的工作流程

主要操作

wait：
- 等待条件满足。
- 调用 wait 时，线程会释放互斥锁并进入等待状态。
- 条件满足后，线程被唤醒并重新获取互斥锁。
notify_one 和 notify_all：
- notify_one：唤醒一个等待线程。
- notify_all：唤醒所有等待线程。

3. 互斥锁和条件变量的配合使用

常见场景

生产者-消费者模型：
- 多线程之间需要协调生产和消费的顺序。
资源池：
- 线程需要等待某些资源释放后才能继续运行。

代码示例：生产者-消费者模型

问题描述

有一个共享队列：
- 生产者线程向队列中添加数据。
- 消费者线程从队列中取出数据。
需要确保队列的线程安全：
- 队列满时，生产者线程需等待。
- 队列空时，消费者线程需等待。

实现代码

  
#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>

std::queue<int> shared_queue;       // 共享队列
std::mutex mtx;                     // 互斥锁
std::condition_variable cond_var;   // 条件变量
const int MAX_QUEUE_SIZE = 10;      // 队列最大容量

// 生产者
void producer(int id) {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cond_var.wait(lock, [] { return shared_queue.size() < MAX_QUEUE_SIZE; }); // 等待队列有空间

        shared_queue.push(i);
        std::cout << "Producer " << id << " produced: " << i << std::endl;

        lock.unlock();
        cond_var.notify_all(); // 通知消费者
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟生产时间
    }
}

// 消费者
void consumer(int id) {
    for (int i = 0; i < 20; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cond_var.wait(lock, [] { return !shared_queue.empty(); }); // 等待队列非空

        int item = shared_queue.front();
        shared_queue.pop();
        std::cout << "Consumer " << id << " consumed: " << item << std::endl;

        lock.unlock();
        cond_var.notify_all(); // 通知生产者
        std::this_thread::sleep_for(std::chrono::milliseconds(150)); // 模拟消费时间
    }
}

int main() {
    std::thread producer1(producer, 1);
    std::thread producer2(producer, 2);
    std::thread consumer1(consumer, 1);
    std::thread consumer2(consumer, 2);

    producer1.join();
    producer2.join();
    consumer1.join();
    consumer2.join();

    return 0;
}

4. 代码解析

互斥锁的作用：
- 保护对共享队列的访问，确保同一时刻只有一个线程操作队列。
条件变量的作用：
- 控制线程等待和唤醒：
  - 当队列满时，生产者等待消费者释放空间。
  - 当队列空时，消费者等待生产者添加数据。
wait 的用法：
- 条件变量的 wait
  方法会：
  1. 自动释放互斥锁，让其他线程可以访问资源。
  2. 等待条件满足。
  3. 条件满足后，自动重新加锁并继续执行。
notify_all 的用法：
- 每次操作完共享队列后，通过 notify_all 唤醒所有等待线程。

5. 常见问题与注意事项

死锁
- 如果忘记在临界区末尾解锁（如漏掉 unlock），可能导致死锁。
- 使用 std::unique_lock 或 std::lock_guard 避免手动解锁遗漏。
虚假唤醒（Spurious Wakeups）
- 条件变量可能会因虚假唤醒而触发。
- 需要在 wait
  中使用条件检查：
  1 cond_var.wait(lock, [] { return 条件; });
竞争条件
- 未正确使用互斥锁或条件变量，可能导致多个线程同时访问共享资源，造成数据不一致。

6. 总结

互斥锁的作用

确保同一时间只有一个线程访问共享资源，防止数据竞争。

条件变量的作用

提供线程间的等待和通知机制，协调线程执行顺序。

两者的配合

互斥锁保护共享资源的访问，条件变量负责线程的等待和唤醒。
适用于生产者-消费者模型、资源池管理等需要线程同步的场景。

如果非堆内存一直在增长，可能哪个区域的内存出了问题

在现代操作系统中，内存通常分为多个区域（如栈、堆、全局/静态区、代码区等）。如果程序运行中非堆内存持续增长，可能是以下内存区域出现了问题：

1. 栈内存问题

原因

递归调用过深：
- 递归函数没有正确终止条件，导致栈帧不断增加。
大局部变量分配：
- 在栈上分配了过大的数组或结构体，超出了栈的容量。
多线程栈开销：
- 如果程序创建了大量线程，每个线程都需要独立的栈空间，可能导致内存消耗迅速增长。

排查方法

检查程序中的递归函数，确保其有正确的终止条件。
避免在栈上分配过大的局部变量，改用堆分配（如 malloc 或 new）。
使用工具监控栈的使用情况（如 Valgrind 或 AddressSanitizer）。

2. 全局/静态内存问题

原因

全局变量或静态变量泄漏：
- 程序中定义了未及时释放的全局变量或静态变量，并不断分配新资源。
静态容器增长：
- 像 std::vector、std::map 等静态容器不断插入数据，但从未清理。

排查方法

检查全局变量和静态变量的使用，确保动态分配的资源在适当时释放。
对静态容器设置上限，定期清理不必要的数据。

3. 内存映射区（Memory Mapping Region）问题

原因

内存映射文件未释放：
- 使用 mmap 或类似机制映射文件到内存后，未调用 munmap 释放内存。
动态库加载过多：
- 程序中动态加载了大量共享库（dlopen），但未正确卸载（dlclose）。

排查方法

检查程序中是否有未正确释放的内存映射文件。
使用工具（如 pmap 或 smem）查看进程的内存映射区域，确认哪些区域增长过快。

4. 堆外缓冲区问题

原因

文件描述符未关闭：
- 打开文件或套接字（如网络连接）未关闭，导致内核分配的缓冲区不断增长。
管道或消息队列堵塞：
- 进程写入管道或消息队列，但另一端未及时读取，导致内核缓冲区增长。

排查方法

使用工具（如 lsof 或 netstat）检查未关闭的文件描述符或套接字。
检查管道或消息队列的使用逻辑，确保数据及时消费。

5. 动态分配的非堆内存

原因

匿名内存分配：
- 某些库或第三方代码使用了匿名内存分配（如 mmap），未通过堆管理。
内存池未清理：
- 自定义的内存池或缓存池可能增长过快，未及时释放过期的内存块。

排查方法

检查程序中是否使用了 mmap 或其他低级内存分配函数。
如果使用了自定义内存池，确认其释放逻辑是否正确。

6. 内核分配的内存

原因

内核缓冲区泄漏：
- 例如网络缓冲区、文件系统缓冲区未及时释放。
设备驱动程序问题：
- 某些设备驱动可能存在内存泄漏问题。

排查方法

使用 top 或 free 查看内存消耗，确认是否是内核分配的内存（如 Slab 区域）。
使用 slabtop 查看内核的 Slab 缓存使用详情。

7. 信号量或共享内存问题

原因

信号量未释放：
- 使用系统 V 信号量（semget）或 POSIX 信号量，未调用 semctl 或 sem_unlink 释放。
共享内存未释放：
- 使用系统 V 共享内存（shmget）或 POSIX 共享内存，未调用 shmctl 或 shm_unlink 释放。

排查方法

使用 ipcs 查看系统 V IPC 资源（信号量、共享内存、消息队列）。
使用工具（如 ipcrm）手动清理未释放的资源。

8. 代码段问题（极少见）

原因

动态生成代码（如 JIT 编译器）时，分配了额外的代码段内存，但未及时回收。

排查方法

检查程序是否涉及动态代码生成或加载，确认其内存释放机制。

排查内存问题的工具和方法

工具推荐
- top/htop：实时查看内存使用。
- pmap：分析进程的内存映射情况。
- valgrind：检测内存泄漏和非法访问。
- lsof：列出进程打开的文件和套接字。
- slabtop：查看内核的内存分配状态。
- strace：跟踪系统调用，查看内存分配相关的操作。
分析步骤
- 初步判断：
  1. 通过 top 或 free 确认内存增长的趋势。
  2. 用 pmap 检查进程的各个内存区域。
- 精细分析：
  1. 使用 valgrind 或 AddressSanitizer 检查内存泄漏。
  2. 检查文件描述符（lsof）或 IPC 资源（ipcs）。
- 定位问题：
  - 确认是用户态问题（如未释放的全局变量）还是内核态问题（如内核缓冲区泄漏）。

总结

非堆内存持续增长可能的区域

栈：递归过深或局部变量过大。
全局/静态区：全局变量或静态容器未及时清理。
内存映射区：未释放的文件映射或动态库。
内核缓冲区：未关闭的文件描述符或网络套接字。
信号量/共享内存：未释放的系统 V 或 POSIX IPC 资源。

通过工具和系统调用分析，结合代码审查，可以定位问题并采取针对性的优化措施。

操作系统, 操作系统面经

C++ 面经操作系统

本文由作者按照 CC BY 4.0 进行授权

分段和分页的区别

1. 基本概念

分段（Segmentation）

分页（Paging）

2. 划分方式

3. 地址转换

分段

分页

4. 优缺点对比

5. 应用场景

分段的应用场景

分页的应用场景

6. 分段与分页的结合

分段-分页结合的内存管理

7. 总结表格

进程间通信原理和方式

进程间通信的原理

进程间通信的常见方式

1. 管道（Pipe）

2. 消息队列（Message Queue）

特点

优点

示例（POSIX 消息队列）

3. 共享内存（Shared Memory）

特点

优点

示例（POSIX 共享内存）

4. 信号（Signal）

特点

示例

5. 套接字（Socket）

特点

示例

6. 信号量（Semaphore）

特点

总结对比

fock()读时共享写时拷贝

1. 什么是读时共享，写时拷贝？

2. 为什么需要写时拷贝？

3. 工作原理

(1) fork() 的执行过程

(2) 写操作触发 COW

4. 示例代码分析

(1) 示例代码

(2) 运行结果

(3) 分析

5. 优点与缺点

优点

缺点

6. 使用场景与优化

(1) 使用场景

(2) 优化建议

7. 总结

互斥锁+条件变量

1. 互斥锁与条件变量的作用

互斥锁（Mutex）

条件变量（Condition Variable）

2. 条件变量的工作流程

主要操作

3. 互斥锁和条件变量的配合使用

常见场景

代码示例：生产者-消费者模型

问题描述

实现代码

4. 代码解析

5. 常见问题与注意事项

6. 总结

互斥锁的作用

条件变量的作用

两者的配合

如果非堆内存一直在增长，可能哪个区域的内存出了问题

1. 栈内存问题

原因

排查方法

2. 全局/静态内存问题

原因

排查方法

3. 内存映射区（Memory Mapping Region）问题

原因

排查方法

(1) `fork()` 的执行过程