进程与线程 ⭐⭐

// PCB 的核心字段（概念模型，非真实内核代码）
struct PCB {
    int pid;                    // 进程ID：全局唯一标识符
    int state;                  // 当前状态：就绪 / 运行 / 阻塞
    int priority;               // 优先级：调度时的权重依据
    struct context cpu_ctx;     // CPU 上下文：寄存器快照（PC, SP, 通用寄存器等）
    struct memory_map *mm;      // 内存映射：页表基址、虚拟地址空间描述
    struct file_desc *open_files; // 打开的文件描述符表
    int parent_pid;             // 父进程ID：记录谁创建了自己
    struct list_head children;  // 子进程链表
    unsigned long start_time;   // 创建时间
    // ... 还有信号处理、资源配额等更多字段
};

#include <stdio.h>      // 标准输入输出
#include <unistd.h>     // fork(), getpid()
#include <sys/types.h>  // pid_t 类型定义
 
int global_var = 100;   // 全局变量——位于数据段
 
int main() {
    pid_t pid = fork();  // 创建子进程：操作系统在此刻为子进程分配全新的资源副本
 
    if (pid < 0) {
        // fork 失败：通常是系统资源不足（内存耗尽、进程数达上限）
        perror("fork failed");
        return 1;
    }
    else if (pid == 0) {
        // ---- 子进程空间 ----
        // 子进程获得了父进程数据段的【副本】（Copy-on-Write 机制下是逻辑副本）
        global_var += 50;  // 修改的是子进程自己的副本，不影响父进程
        printf("[Child]  PID=%d, global_var=%d\n", getpid(), global_var);
        // 输出: global_var = 150
    }
    else {
        // ---- 父进程空间 ----
        sleep(1);          // 等待子进程先执行（简单演示用，非严谨同步）
        printf("[Parent] PID=%d, global_var=%d\n", getpid(), global_var);
        // 输出: global_var = 100  ← 父进程的数据未被子进程修改
    }
    return 0;
}

#include <stdio.h>
 
int global_init = 42;       // Data 段：已初始化全局变量
int global_uninit;           // BSS 段：未初始化全局变量（自动为0）
 
int main() {
    int local_var = 7;       // Stack：局部变量，位于栈帧中
    int *heap_var = (int *)malloc(sizeof(int)); // Heap：动态分配
    *heap_var = 99;          // 向堆内存写入值
 
    // 打印各变量的虚拟地址，观察它们所在的段
    printf("Text  (main func) : %p\n", (void *)main);        // 代码段地址
    printf("Data  (global_init): %p\n", (void *)&global_init); // 数据段地址
    printf("BSS   (global_uninit): %p\n", (void *)&global_uninit); // BSS段地址
    printf("Heap  (heap_var)  : %p\n", (void *)heap_var);     // 堆地址
    printf("Stack (local_var) : %p\n", (void *)&local_var);   // 栈地址
 
    free(heap_var);          // 释放堆内存，避免内存泄漏
    return 0;
}

#include <stdio.h>
#include <unistd.h>
 
int main() {
    // 此刻进程处于 Running 状态（正在 CPU 上执行）
 
    printf("开始读取文件...\n");
 
    FILE *f = fopen("/data/large_file.bin", "r");
    // fopen() 内部发起磁盘 I/O 系统调用
    // ──────────────────────────────────────
    // Running → Blocked（等待磁盘数据）
    // 调度器将 CPU 交给其他 Ready 进程
    // ──────────────────────────────────────
    // ... 磁盘控制器读取完毕，触发硬件中断 ...
    // Blocked → Ready（进入就绪队列排队）
    // ──────────────────────────────────────
    // ... 调度器再次选中本进程 ...
    // Ready → Running（继续执行下一条指令）
 
    if (f != NULL) {
        char buf[1024];
        fread(buf, 1, 1024, f);  // 又一次 I/O → 又一轮状态切换
        fclose(f);               // 关闭文件描述符
    }
 
    printf("文件读取完成！\n");
    return 0;
    // Running → Terminated（进程正常退出）
}

// ===== 进程地址空间内存布局（含多线程）=====
//
// 高地址
// ┌──────────────────────────────────┐
// │         内核空间 (Kernel)         │  ← 用户不可直接访问
// ├──────────────────────────────────┤
// │       线程 3 的栈 (Stack)        │  ← 私有：局部变量、调用帧
// │            ↓ 向下增长             │
// ├──────────────────────────────────┤
// │       线程 2 的栈 (Stack)        │  ← 私有
// │            ↓ 向下增长             │
// ├──────────────────────────────────┤
// │       线程 1 (主线程) 的栈        │  ← 私有
// │            ↓ 向下增长             │
// ├──────────────────────────────────┤
// │                                  │
// │       ↑ 向上增长                  │
// │        堆 (Heap) ── 共享         │  ← malloc/new 分配
// ├──────────────────────────────────┤
// │   未初始化数据段 (BSS) ── 共享    │  ← 未赋初值的全局/静态变量
// ├──────────────────────────────────┤
// │   已初始化数据段 (Data) ── 共享   │  ← 赋了初值的全局/静态变量
// ├──────────────────────────────────┤
// │      代码段 (Text) ── 共享       │  ← 可执行指令，只读
// └──────────────────────────────────┘
// 低地址

#include <stdio.h>    // 标准输入输出
#include <pthread.h>  // POSIX 线程库
 
int counter = 0;      // 共享的全局变量，所有线程均可访问
 
// 线程执行函数：对 counter 累加 100000 次
void* increment(void* arg) {
    for (int i = 0; i < 100000; i++) {
        counter++;    // ⚠️ 非原子操作！实际上是：读 → 加1 → 写 三步
                      // 多线程并发执行时，可能发生数据覆盖
    }
    return NULL;      // 线程执行结束
}
 
int main() {
    pthread_t t1, t2;                     // 声明两个线程变量
 
    pthread_create(&t1, NULL, increment, NULL);  // 创建线程1，执行 increment
    pthread_create(&t2, NULL, increment, NULL);  // 创建线程2，执行 increment
 
    pthread_join(t1, NULL);               // 等待线程1结束
    pthread_join(t2, NULL);               // 等待线程2结束
 
    // 期望结果: 200000
    // 实际结果: 往往小于 200000，因为两个线程交替执行时发生了"丢失更新"
    printf("Counter = %d\n", counter);    // 输出最终计数值
    return 0;
}

// ============================================================
//        进程 A (PID: 1001)          进程 B (PID: 1002)
// ============================================================
//
//   虚拟地址空间 (独立)             虚拟地址空间 (独立)
//  ┌─────────────────┐           ┌─────────────────┐
//  │   Stack (栈)     │           │   Stack (栈)     │
//  │  局部变量/调用帧  │           │  局部变量/调用帧  │
//  ├─────────────────┤           ├─────────────────┤
//  │       ↓          │           │       ↓          │
//  │   (空闲区域)     │           │   (空闲区域)     │
//  │       ↑          │           │       ↑          │
//  ├─────────────────┤           ├─────────────────┤
//  │   Heap (堆)      │           │   Heap (堆)      │
//  │  malloc/new 分配  │           │  malloc/new 分配  │
//  ├─────────────────┤           ├─────────────────┤
//  │   BSS (未初始化)  │           │   BSS (未初始化)  │
//  ├─────────────────┤           ├─────────────────┤
//  │   Data (已初始化) │           │   Data (已初始化) │
//  ├─────────────────┤           ├─────────────────┤
//  │   Text (代码段)   │           │   Text (代码段)   │
//  └─────────────────┘           └─────────────────┘
//         │                              │
//     ┌───┘ 页表A                    ┌───┘ 页表B
//     ▼                              ▼
//  ┌──────────────────────────────────────────────┐
//  │          物理内存 (Physical Memory)           │
//  │  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐     │
//  │  │ 帧 0  │  │ 帧 1  │  │ 帧 2  │  │ 帧 3  │ ... │
//  │  │(A用)  │  │(B用)  │  │(A用)  │  │(B用)  │     │
//  │  └──────┘  └──────┘  └──────┘  └──────┘     │
//  └──────────────────────────────────────────────┘

// ======================================================================
//                     进程 P (PID: 2001)
//              ┌─────────────────────────────────┐
//              │     共享地址空间 (Shared)         │
//              │  ┌───────────────────────────┐   │
//              │  │  Text (代码段) - 共享       │   │
//              │  │  Data (全局变量) - 共享     │   │
//              │  │  Heap (堆) - 共享          │   │
//              │  │  文件描述符表 - 共享        │   │
//              │  └───────────────────────────┘   │
//              │                                   │
//              │  ┌─────────┐  ┌─────────┐        │
//              │  │ 线程 T1  │  │ 线程 T2  │       │
//              │  │ ──────── │  │ ──────── │       │
//              │  │ Stack_1  │  │ Stack_2  │  私有  │
//              │  │ PC_1     │  │ PC_2     │  资源  │
//              │  │ Regs_1   │  │ Regs_2   │       │
//              │  │ TCB_1    │  │ TCB_2    │       │
//              │  └─────────┘  └─────────┘        │
//              └─────────────────────────────────┘
// ======================================================================

#include <stdio.h>      // 标准输入输出
#include <unistd.h>     // fork, getpid
#include <sys/wait.h>   // wait
 
int shared_var = 100;   // 全局变量，fork 后父子各持一份副本
 
int main() {
    pid_t pid = fork();  // 创建子进程，子进程获得父进程地址空间的【完整拷贝】
 
    if (pid == 0) {
        // ---- 子进程空间 ----
        shared_var += 50;                       // 修改的是子进程自己的副本
        printf("[Child]  PID=%d, shared_var=%d\n",
               getpid(), shared_var);           // 输出: 150
    } else {
        wait(NULL);                             // 等待子进程结束
        // ---- 父进程空间 ----
        printf("[Parent] PID=%d, shared_var=%d\n",
               getpid(), shared_var);           // 输出: 100（未受影响！）
    }
    return 0;
}
// 运行结果:
// [Child]  PID=1002, shared_var=150
// [Parent] PID=1001, shared_var=100
// 结论: 父子进程的 shared_var 是两个完全独立的内存副本

#include <stdio.h>      // 标准输入输出
#include <pthread.h>    // POSIX 线程库
 
int shared_var = 100;   // 全局变量，所有线程共享同一份
 
void *thread_func(void *arg) {
    // ---- 子线程 ----
    shared_var += 50;                           // 直接修改同一块内存
    printf("[Thread] shared_var=%d\n",
           shared_var);                         // 输出: 150
    return NULL;
}
 
int main() {
    pthread_t tid;                              // 线程标识符
    pthread_create(&tid, NULL,
                   thread_func, NULL);          // 创建子线程（共享地址空间）
    pthread_join(tid, NULL);                    // 等待子线程结束
 
    // ---- 主线程 ----
    printf("[Main]   shared_var=%d\n",
           shared_var);                         // 输出: 150（被子线程修改了！）
    return 0;
}
// 运行结果:
// [Thread] shared_var=150
// [Main]   shared_var=150
// 结论: 两个线程操作的是同一个 shared_var，修改立即可见

// 进程销毁的核心步骤（内核视角伪代码）
void destroy_process(PCB *pcb) {
    release_address_space(pcb->page_table);   // 释放整个页表和关联的物理帧
    close_all_fds(pcb->fd_table);             // 关闭所有文件描述符
    release_signal_handlers(pcb->sig_table);  // 释放信号处理表
    remove_from_scheduler(pcb);               // 从调度队列移除
    free_pcb(pcb);                            // 释放 PCB 结构体本身
}
 
// 线程销毁的核心步骤（内核视角伪代码）
void destroy_thread(TCB *tcb) {
    release_thread_stack(tcb->stack);         // 释放线程栈（通常几 MB）
    remove_from_scheduler(tcb);               // 从调度队列移除
    free_tcb(tcb);                            // 释放 TCB 结构体本身
    // 地址空间? 不动! 文件表? 不动! 因为它们属于进程
}

#include <stdio.h>
#include <pthread.h>
 
// 共享数据结构 —— 所有线程都可以直接访问
typedef struct {
    int buffer[1024];    // 共享缓冲区
    int count;           // 当前数据量
} SharedData;
 
SharedData data = { .count = 0 };  // 全局共享实例
 
void *producer(void *arg) {
    for (int i = 0; i < 100; i++) {
        data.buffer[data.count] = i;   // 直接写入共享缓冲区（无需系统调用）
        data.count++;                   // 更新计数（直接操作共享变量）
    }
    return NULL;
}
 
void *consumer(void *arg) {
    while (data.count > 0) {
        data.count--;                   // 直接读取共享变量
        int val = data.buffer[data.count]; // 直接从共享缓冲区取数据
        printf("consumed: %d\n", val);
    }
    return NULL;
}
// ⚠️ 注意：此代码没有任何同步机制，存在严重的竞态条件（Race Condition）
// 这里仅用于演示"线程可以直接通信"这一特性，实际使用必须加锁！

// ===================================================================
//   线程通信 vs 进程通信（管道）的数据流路径对比
// ===================================================================
//
//   【线程通信】直接内存访问，零拷贝
//   ┌──────────┐                    ┌──────────┐
//   │ Thread A  │ ── 写入共享变量 ──→ │ Thread B  │
//   │ (用户态)  │    (同一地址空间)   │ (用户态)  │
//   └──────────┘                    └──────────┘
//        延迟: ~ 几纳秒 (ns)
//
//
//   【进程通信 - 管道】需经过内核两次拷贝
//   ┌──────────┐     ┌────────────┐     ┌──────────┐
//   │ Process A │ ──→ │   内核缓冲区  │ ──→ │ Process B │
//   │ (用户态)  │     │  (内核态)    │     │ (用户态)  │
//   └──────────┘     └────────────┘     └──────────┘
//    write()系统调用    内核管理缓冲     read()系统调用
//    用户→内核 拷贝1                    内核→用户 拷贝2
//        延迟: ~ 几微秒 (μs)，差 1000 倍量级
// ===================================================================

#include <stdio.h>
#include <pthread.h>
 
int counter = 0;              // 共享计数器
 
void *increment(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;            // ⚠️ 非原子操作! 实际分三步:
                              //   1. 读取 counter 到寄存器 (LOAD)
                              //   2. 寄存器值 +1           (ADD)
                              //   3. 写回内存              (STORE)
                              // 两个线程可能同时读到相同的旧值!
    }
    return NULL;
}
 
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);  // 线程1: counter += 1000000
    pthread_create(&t2, NULL, increment, NULL);  // 线程2: counter += 1000000
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
 
    printf("Expected: 2000000\n");
    printf("Actual:   %d\n", counter);  // 实际结果几乎总是 < 2000000!
    return 0;
}
// 典型输出:
// Expected: 2000000
// Actual:   1387456    <-- 每次运行结果都不同，且小于预期

// 竞态条件时序示例（counter 当前值为 42）
//
// 时间线 ──→
//
// T1:  LOAD counter (读到 42)
// T2:                          LOAD counter (也读到 42)
// T1:  ADD 1 (寄存器 = 43)
// T2:                          ADD 1 (寄存器 = 43)
// T1:  STORE counter (写入 43)
// T2:                          STORE counter (写入 43)
//
// 结果: counter = 43，但执行了两次 ++，应该是 44！
// 丢失了一次更新（Lost Update）

// 线程的"连坐效应"
void *bad_thread(void *arg) {
    int *p = NULL;         // 空指针
    *p = 42;               // 💥 触发 SIGSEGV (Segmentation Fault)
    return NULL;            // 永远不会执行到这里
}
// 结果: 操作系统向整个进程发送 SIGSEGV 信号
// 进程内的所有线程一起被终止！
// 不像进程那样有天然的隔离屏障

#include <stdio.h>
#include <pthread.h>
 
int counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;  // 初始化互斥锁
 
void *safe_increment(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);     // 🔒 加锁: 进入临界区前获取互斥锁
        counter++;                     // 临界区: 此时只有一个线程能执行这行
        pthread_mutex_unlock(&lock);   // 🔓 解锁: 离开临界区，释放互斥锁
    }
    return NULL;
}
 
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_increment, NULL);
    pthread_create(&t2, NULL, safe_increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
 
    printf("Result: %d\n", counter);   // ✅ 输出: 2000000（结果正确）
    return 0;
}

# Shell 管道：ls 的 stdout 通过管道连接到 grep 的 stdin
ls -la | grep ".txt"

// pipe() 系统调用原型
// 创建管道，fd[0] 为读端，fd[1] 为写端
int pipe(int fd[2]);

#include <stdio.h>    // printf
#include <unistd.h>   // pipe, fork, read, write, close
#include <string.h>   // strlen
#include <sys/wait.h> // wait
 
int main() {
    int fd[2];            // fd[0] = 读端, fd[1] = 写端
    pid_t pid;            // 进程 ID
    char buf[128];        // 读取缓冲区
 
    // 1. 创建管道（必须在 fork 之前，否则父子进程无法共享同一管道）
    if (pipe(fd) == -1) {
        perror("pipe failed");  // 管道创建失败
        return 1;
    }
 
    // 2. fork 创建子进程
    pid = fork();
 
    if (pid < 0) {
        perror("fork failed");  // fork 失败
        return 1;
    }
 
    if (pid > 0) {
        // ===== 父进程（写端） =====
        close(fd[0]);           // 关闭父进程不需要的读端（重要！避免资源泄漏）
 
        const char *msg = "Hello from parent!";  // 要发送的消息
        write(fd[1], msg, strlen(msg));           // 将消息写入管道写端
        close(fd[1]);           // 写完后关闭写端，子进程 read() 将收到 EOF
 
        wait(NULL);             // 等待子进程结束，防止僵尸进程
    } else {
        // ===== 子进程（读端） =====
        close(fd[1]);           // 关闭子进程不需要的写端
 
        int n = read(fd[0], buf, sizeof(buf) - 1); // 从管道读端读取数据
        buf[n] = '\0';          // 手动添加字符串结束符
        printf("Child received: %s\n", buf);        // 输出接收到的消息
        close(fd[0]);           // 读完后关闭读端
    }
 
    return 0;
}
// 输出: Child received: Hello from parent!

#include <sys/stat.h>  // mkfifo
#include <fcntl.h>     // open, O_WRONLY, O_RDONLY
 
// 创建命名管道（文件路径 /tmp/my_fifo，权限 0666）
// 如果文件已存在，mkfifo 会返回 -1 并设置 errno = EEXIST
mkfifo("/tmp/my_fifo", 0666);
 
// ----- 进程 A（写入端） -----
int fd_w = open("/tmp/my_fifo", O_WRONLY);  // 以只写模式打开 FIFO
write(fd_w, "data", 4);                     // 写入 4 字节数据
close(fd_w);                                // 关闭文件描述符
 
// ----- 进程 B（读取端） -----
int fd_r = open("/tmp/my_fifo", O_RDONLY);  // 以只读模式打开同一 FIFO
char buf[128];                              // 读取缓冲区
read(fd_r, buf, sizeof(buf));               // 从 FIFO 读取数据
close(fd_r);                                // 关闭文件描述符

# 终端 1：创建命名管道并读取
mkfifo /tmp/my_fifo
cat < /tmp/my_fifo          # 阻塞等待数据
 
# 终端 2：向命名管道写入
echo "Hello IPC!" > /tmp/my_fifo   # 终端 1 将立即打印 Hello IPC!

#include <sys/ipc.h>  // ftok, IPC_CREAT
#include <sys/msg.h>  // msgget, msgsnd, msgrcv, msgctl
 
// 消息结构体（用户自定义，但第一个字段必须是 long 类型的 mtype）
struct msg_buf {
    long mtype;        // 消息类型，必须 > 0
    char mtext[256];   // 消息正文（可自定义大小）
};
 
// ===== 发送端 =====
// 1. 生成唯一的 IPC key（基于路径 + 项目 ID）
key_t key = ftok("/tmp", 'A');            // 'A' 是 project ID，可以是任意非零字符
 
// 2. 创建或获取消息队列（IPC_CREAT: 不存在则创建；0666: 权限）
int msqid = msgget(key, IPC_CREAT | 0666);
 
// 3. 构造消息
struct msg_buf msg;                       // 声明消息结构体
msg.mtype = 1;                            // 设置消息类型为 1
strcpy(msg.mtext, "Hello MQ!");           // 填充消息内容
 
// 4. 发送消息（0 = 若队列满则阻塞等待）
msgsnd(msqid, &msg, strlen(msg.mtext) + 1, 0);
// 参数: 队列ID, 消息指针, 消息体大小(不含mtype), 标志位
 
// ===== 接收端 =====
struct msg_buf recv_msg;                  // 用于接收消息的缓冲区
 
// 5. 接收类型为 1 的消息（0 标志 = 阻塞等待）
msgrcv(msqid, &recv_msg, sizeof(recv_msg.mtext), 1, 0);
// 参数: 队列ID, 缓冲区, 最大接收大小, 期望的消息类型, 标志位
// mtype=0: 接收队列中第一条消息（不区分类型）
// mtype>0: 只接收该类型的第一条消息
// mtype<0: 接收类型值 <= |mtype| 的最小类型的第一条消息
 
printf("Received: %s\n", recv_msg.mtext); // 输出: Received: Hello MQ!
 
// 6. 用完后销毁消息队列（IPC_RMID = 立即移除）
msgctl(msqid, IPC_RMID, NULL);

#include <sys/ipc.h>  // ftok, IPC_CREAT
#include <sys/shm.h>  // shmget, shmat, shmdt, shmctl
#include <string.h>   // strcpy
#include <stdio.h>    // printf
 
// ===== 写入端（进程 A）=====
// 1. 生成 IPC key
key_t key = ftok("/tmp", 'S');                   // 与消息队列类似的 key 生成方式
 
// 2. 创建共享内存段（大小 4096 字节）
int shmid = shmget(key, 4096, IPC_CREAT | 0666);
// 参数: key, 大小(字节), 标志(创建+权限)
 
// 3. 将共享内存附加到当前进程的地址空间
// shmat 返回映射后的虚拟地址指针
// 第二个参数 NULL 表示让内核自动选择映射地址
// 第三个参数 0 表示可读可写
char *addr = (char *)shmat(shmid, NULL, 0);
 
// 4. 直接写入数据（就像操作普通内存一样！）
strcpy(addr, "Hello Shared Memory!");            // 直接 memcpy/strcpy，无需系统调用
 
// 5. 使用完毕后分离（Detach），但不销毁
shmdt(addr);
// 注意：shmdt 只是解除当前进程的映射，共享内存段本身仍然存在于内核
 
// ===== 读取端（进程 B）=====
// 使用相同的 key 获取同一块共享内存
int shmid2 = shmget(key, 4096, 0666);           // 不需要 IPC_CREAT（已存在）
char *addr2 = (char *)shmat(shmid2, NULL, 0);   // 附加到进程 B 的地址空间
 
printf("Read: %s\n", addr2);                     // 输出: Read: Hello Shared Memory!
 
shmdt(addr2);                                    // 分离
 
// 6. 最终由某个进程销毁共享内存段
shmctl(shmid, IPC_RMID, NULL);                   // IPC_RMID: 标记为待销毁
// 内核将在所有进程都 detach 后真正释放该内存

#include <sys/mman.h>   // mmap, munmap
#include <fcntl.h>      // shm_open, O_CREAT, O_RDWR
#include <unistd.h>     // ftruncate, close
 
// 1. 创建或打开一个 POSIX 共享内存对象（本质是 /dev/shm/ 下的文件）
int fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
 
// 2. 设置共享内存大小
ftruncate(fd, 4096);                    // 将文件/共享对象截断为 4096 字节
 
// 3. 映射到进程地址空间
char *ptr = (char *)mmap(
    NULL,                               // addr: 内核自动选择映射地址
    4096,                               // length: 映射大小
    PROT_READ | PROT_WRITE,             // prot: 可读 + 可写
    MAP_SHARED,                         // flags: 共享映射（多进程可见）
    fd,                                 // fd: 共享内存文件描述符
    0                                   // offset: 从文件头开始映射
);
 
close(fd);                              // 映射建立后可以关闭 fd
 
// 4. 直接读写
strcpy(ptr, "Hello mmap!");             // 写入
printf("%s\n", ptr);                    // 读取
 
// 5. 解除映射并删除
munmap(ptr, 4096);                      // 解除映射
shm_unlink("/my_shm");                  // 删除共享内存对象

#include <semaphore.h>  // sem_open, sem_wait, sem_post, sem_close, sem_unlink
#include <fcntl.h>      // O_CREAT
 
// ===== 初始化 =====
// 创建命名信号量（跨进程共享）
// 名称: "/my_sem"
// O_CREAT: 不存在则创建
// 0666: 权限
// 1: 初始值为 1（表示资源可用 / 相当于互斥锁）
sem_t *sem = sem_open("/my_sem", O_CREAT, 0666, 1);
 
// ===== 进程 A / B 中使用 =====
sem_wait(sem);      // P 操作：尝试获取信号量（若为 0 则阻塞）
                    // --- 临界区开始 ---
 
// 在这里安全地访问共享内存...
// 例如: shared_data->counter++;
 
                    // --- 临界区结束 ---
sem_post(sem);      // V 操作：释放信号量（值 +1，唤醒等待者）
 
// ===== 清理 =====
sem_close(sem);     // 关闭当前进程对信号量的引用
sem_unlink("/my_sem"); // 从系统中删除命名信号量

// 伪代码：生产者-消费者模式（共享内存 + 信号量）
 
sem_t *mutex = sem_open("/mutex", O_CREAT, 0666, 1);  // 互斥信号量，初始 1
sem_t *empty = sem_open("/empty", O_CREAT, 0666, 10);  // 空槽数量，初始 10（缓冲区大小）
sem_t *full  = sem_open("/full",  O_CREAT, 0666, 0);   // 已用槽数量，初始 0
 
// ===== 生产者进程 =====
void producer() {
    while (1) {
        int item = produce_item();       // 生产一个数据项
 
        sem_wait(empty);                 // P(empty): 等待空槽（empty--）
        sem_wait(mutex);                 // P(mutex): 进入临界区
 
        put_item_to_shared_memory(item); // 将数据写入共享内存缓冲区
 
        sem_post(mutex);                 // V(mutex): 离开临界区
        sem_post(full);                  // V(full): 通知消费者有新数据（full++）
    }
}
 
// ===== 消费者进程 =====
void consumer() {
    while (1) {
        sem_wait(full);                  // P(full): 等待有数据（full--）
        sem_wait(mutex);                 // P(mutex): 进入临界区
 
        int item = get_item_from_shared_memory(); // 从共享内存读取数据
 
        sem_post(mutex);                 // V(mutex): 离开临界区
        sem_post(empty);                 // V(empty): 通知生产者有空槽（empty++）
 
        consume_item(item);              // 消费数据
    }
}

#include <stdio.h>       // printf, perror
#include <string.h>      // memset, strlen
#include <unistd.h>      // read, write, close
#include <arpa/inet.h>   // socket, bind, listen, accept, htons, INADDR_ANY
#include <sys/socket.h>  // socket 相关结构体
 
int main() {
    int server_fd, client_fd;              // 服务端监听 fd 和客户端连接 fd
    struct sockaddr_in addr;               // IPv4 地址结构体
    char buf[1024];                        // 读取缓冲区
 
    // 1. 创建 TCP 套接字
    //    AF_INET: IPv4 协议族
    //    SOCK_STREAM: 面向连接的字节流（TCP）
    //    0: 自动选择协议（TCP）
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
 
    // 2. 配置服务端地址
    memset(&addr, 0, sizeof(addr));        // 清零结构体
    addr.sin_family = AF_INET;             // IPv4
    addr.sin_addr.s_addr = INADDR_ANY;     // 绑定所有网络接口（0.0.0.0）
    addr.sin_port = htons(8080);           // 端口号 8080（htons: 主机字节序→网络字节序）
 
    // 3. 绑定地址到套接字
    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
 
    // 4. 开始监听，backlog = 5（等待连接队列最大长度）
    listen(server_fd, 5);
    printf("Server listening on port 8080...\n");
 
    // 5. 接受客户端连接（阻塞，直到有客户端 connect）
    //    返回一个新的 fd 专门用于与该客户端通信
    client_fd = accept(server_fd, NULL, NULL);
 
    // 6. 读取客户端发送的数据
    int n = read(client_fd, buf, sizeof(buf) - 1);  // 从客户端 fd 读取
    buf[n] = '\0';                                    // 添加字符串结束符
    printf("Received: %s\n", buf);
 
    // 7. 向客户端发送响应
    const char *resp = "Hello from Server!";
    write(client_fd, resp, strlen(resp));
 
    // 8. 关闭连接
    close(client_fd);                      // 关闭与客户端的连接
    close(server_fd);                      // 关闭监听套接字
 
    return 0;
}

#include <stdio.h>       // printf
#include <string.h>      // strlen, memset
#include <unistd.h>      // read, write, close
#include <arpa/inet.h>   // socket, connect, inet_pton, htons
 
int main() {
    int sock_fd;                           // 客户端套接字 fd
    struct sockaddr_in serv_addr;          // 服务端地址
    char buf[1024];                        // 读取缓冲区
 
    // 1. 创建 TCP 套接字
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
 
    // 2. 配置服务端地址
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;                   // IPv4
    serv_addr.sin_port = htons(8080);                 // 服务端端口
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr); // 将点分十进制IP转为二进制
 
    // 3. 发起连接（触发 TCP 三次握手）
    connect(sock_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
 
    // 4. 发送数据到服务端
    const char *msg = "Hello from Client!";
    write(sock_fd, msg, strlen(msg));
 
    // 5. 读取服务端的响应
    int n = read(sock_fd, buf, sizeof(buf) - 1);
    buf[n] = '\0';
    printf("Server replied: %s\n", buf);              // 输出: Server replied: Hello from Server!
 
    // 6. 关闭连接
    close(sock_fd);
 
    return 0;
}

#include <sys/socket.h>  // socket, bind, listen, accept, connect
#include <sys/un.h>      // sockaddr_un, AF_UNIX
 
// 服务端核心代码片段
int server_fd = socket(AF_UNIX, SOCK_STREAM, 0);  // 使用 AF_UNIX 而非 AF_INET
 
struct sockaddr_un addr;                           // Unix 域地址结构体
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;                         // Unix 域协议族
strncpy(addr.sun_path, "/tmp/my.sock", sizeof(addr.sun_path) - 1);
// sun_path: 套接字文件路径（代替了 IP:Port）
 
unlink("/tmp/my.sock");                            // 删除可能残留的旧文件
bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
listen(server_fd, 5);                              // 开始监听
// 后续 accept/read/write 与 TCP 完全一致