C++ Linux 编程知识点详解

#include <unistd.h>
#include <sys/wait.h>
#include <pthread.h>
#include <cstdio>

void* worker(void*) {
    printf("子线程 pid=%d\n", getpid());
    return nullptr;
}

int main() {
    // 1. 创建进程
    pid_t pid = fork();
    if (pid == 0) {
        printf("子进程 pid=%d\n", getpid());
    } else {
        waitpid(pid, nullptr, 0);   // 父进程等待子进程
    }

    // 2. 创建线程
    pthread_t t;
    pthread_create(&t, nullptr, worker, nullptr);
    pthread_join(t, nullptr);       // 等待线程结束
    return 0;
}

#include <unistd.h>
#include <sys/wait.h>
#include <cstdio>
#include <cstring>

char global_buf[4096];

int main() {
    strcpy(global_buf, "hello");
    pid_t pid = fork();
    if (pid == 0) {
        // 子进程写这一页 → 触发 COW，真正复制该页
        strcpy(global_buf, "child");
        printf("child: %s\n", global_buf);
    } else {
        wait(nullptr);
        printf("parent: %s\n", global_buf); // 父进程不受影响
    }
    return 0;
}

#include <unistd.h>
#include <sys/wait.h>
#include <cstdio>

int main() {
    pid_t pid = fork();
    if (pid == 0) {
        _exit(0);              // 子进程立即退出 → 变僵尸
    }
    sleep(5);                  // 这 5 秒内子进程是僵尸状态
    waitpid(pid, nullptr, 0);  // 回收，僵尸消失
    return 0;
}

ps aux | grep Z      # STAT 列为 Z 即僵尸
top                  # 顶部显示 "zombie" 数量

// 方法一：显式 wait / waitpid
waitpid(pid, nullptr, 0);

// 方法二：忽略 SIGCHLD，内核自动回收
signal(SIGCHLD, SIG_IGN);

// 方法三：SIGCHLD 处理器里调用 wait
void handler(int) { while (waitpid(-1, nullptr, WNOHANG) > 0); }

// 方法四（经典）：二次 fork，让孙进程被 init 收养
if (fork() == 0) {
    if (fork() == 0) { /* 真正干活，父进程(SIGCHLD已处理)变孤儿 */ _exit(0); }
    _exit(0);
}

#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstring>

int main() {
    // O_RDWR 读写, O_CREAT 不存在则创建, 0666 权限
    int fd = open("/tmp/test.txt", O_RDWR | O_CREAT, 0644);
    if (fd < 0) { perror("open"); return 1; }

    const char* msg = "hello linux\n";
    write(fd, msg, strlen(msg));

    lseek(fd, 0, SEEK_SET);      // 移回文件头
    char buf[64] = {0};
    ssize_t n = read(fd, buf, sizeof(buf));
    printf("read %zd bytes: %s", n, buf);

    close(fd);
    return 0;
}

int fd = open("/dev/tty", O_RDONLY | O_NONBLOCK);
char c;
ssize_t n = read(fd, &c, 1);
if (n < 0 && errno == EAGAIN) {
    printf("暂无输入，先干别的\n");
}
// 运行中动态切换阻塞态
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);

#include <cstdio>
#include <unistd.h>
#include <fcntl.h>

int main() {
    // 系统 IO：每个 write 都是一次系统调用
    int fd = open("/tmp/a.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    write(fd, "x", 1);        // 1 次 syscall
    write(fd, "y", 1);        // 又 1 次 syscall
    close(fd);

    // 标准 IO：先写进 FILE* 的用户态缓冲区
    FILE* fp = fopen("/tmp/b.txt", "w");
    fputc('x', fp);           // 只进缓冲区，不落盘
    fputc('y', fp);
    fflush(fp);               // 才触发一次 write
    fclose(fp);
    return 0;
}

虚拟地址 = 页号(P) | 页内偏移(D)
  │ 查页表
  ▼
物理地址 = 物理页框号 | 页内偏移(D)

#include <unistd.h>
#include <cstdio>
int main() {
    printf("页大小: %ld 字节\n", sysconf(_SC_PAGESIZE)); // 通常 4096
    return 0;
}

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstring>
#include <sys/stat.h>

int main() {
    int fd = open("/tmp/data.bin", O_RDWR | O_CREAT, 0644);
    ftruncate(fd, 4096);                       // 保证文件有 4096 字节

    // MAP_SHARED: 修改会写回文件并跨进程共享；MAP_PRIVATE: COW
    char* p = (char*)mmap(nullptr, 4096, PROT_READ | PROT_WRITE,
                          MAP_SHARED, fd, 0);
    if (p == MAP_FAILED) { perror("mmap"); return 1; }

    strcpy(p, "mapped data");                  // 直接写内存 = 写文件
    msync(p, 4096, MS_SYNC);                   // 刷回磁盘
    munmap(p, 4096);
    close(fd);
    return 0;
}

#include <cstdio>
#include <unistd.h>
#include <sys/resource.h>
int main() {
    struct rusage ru;
    getrusage(RUSAGE_SELF, &ru);
    // ru_minflt: 次缺页次数; ru_majflt: 主缺页次数
    printf("minor faults=%ld, major faults=%ld\n",
           ru.ru_minflt, ru.ru_majflt);
    return 0;
}

#include <cstdlib>
#include <cstdio>
int main() {
    // 小块：走 brk，堆顶向上增长
    char* small = (char*)malloc(1024);
    // 大块：走 mmap，独立映射
    char* big   = (char*)malloc(1024 * 1024);   // 1MB，超过阈值
    printf("small=%p big=%p\n", small, big);
    free(small);
    free(big);
    return 0;
}

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

void on_sigint(int sig) {
    printf("收到 SIGINT(%d)，优雅退出\n", sig);
    _exit(0);
}

int main() {
    signal(SIGINT, on_sigint);       // 注册 handler
    signal(SIGPIPE, SIG_IGN);        // 忽略
    while (1) pause();               // 挂起等待信号
    return 0;
}

gcc -g -O0 -o app main.c     # -g 调试信息, -O0 关优化便于调试
gdb ./app                    # 启动
gdb --args ./app arg1        # 带参数
gdb -p 12345                 # 附加到运行中的进程

break main                 # 在函数入口断点
break file.cpp:42          # 在文件第 42 行断点
break func if x > 10       # 条件断点
run                        # 运行到断点
next  (n)                  # 单步（不进入函数）
step  (s)                  # 单步（进入函数）
finish                     # 执行完当前函数返回
continue (c)               # 继续到下一断点
print x                    # 打印变量
print/x addr               # 以十六进制打印
display x                  # 每步自动显示
backtrace (bt)             # 查看调用栈
frame 1                    # 切换栈帧
info locals                # 当前帧局部变量
info threads               # 查看线程
thread 2                   # 切换线程
watch x                    # 监视变量被修改
list                       # 显示源码
core-file core             # 分析 core dump

# 崩溃后分析 core dump
ulimit -c unlimited
./app
gdb ./app core
bt        # 直接定位崩溃栈

# 1. 统计整体计数（指令数、cache miss、上下文切换等）
perf stat ./app

# 2. 采样热点（哪个函数耗时最多）
perf record -g ./app        # -g 记录调用栈
perf report                 # 交互查看热点函数

# 3. 实时 top 看热点
perf top

# 4. 查看可用事件
perf list

# 5. 分析具体事件（如缓存未命中）
perf stat -e cache-misses,cache-references ./app

# 生成火焰图（定位 CPU 瓶颈）
perf record -g -F 99 ./app        # 99Hz 采样
perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg

strace ./app                    # 跟踪所有系统调用
strace -f ./app                 # 跟踪 fork 出的子进程
strace -p 12345                 # 附加到运行中进程
strace -e trace=open,read,write ./app   # 只看指定调用
strace -e trace=network ./app   # 网络相关
strace -c ./app                 # 统计各系统调用次数/耗时
strace -tt -o trace.log ./app   # 带时间戳输出到文件

open("/etc/ld.so.cache", O_RDONLY) = 3
open("/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\2\1\1\3...", 832) = 832
write(1, "hello\n", 6) = 6

gcc -g -O0 -o app app.c
valgrind --leak-check=full --show-leak-kinds=all ./app
valgrind --tool=memcheck --track-origins=yes ./app   # 追踪未初始化值来源

#include <cstdlib>
int main() {
    int* p = new int[10];
    p[10] = 1;          // 越界写
    int* leak = new int[100];  // 泄漏
    delete[] p;
    return 0;
}

gcc -E hello.c -o hello.i   # 预处理
gcc -S hello.i -o hello.s   # 编译成汇编
gcc -c hello.s -o hello.o   # 汇编成目标文件
gcc hello.o -o hello        # 链接

// hello.c
#include <stdio.h>
#define MSG "hello"
int main() { printf("%s\n", MSG); return 0; }

gcc -c add.c -o add.o
ar rcs libadd.a add.o              # r=插入 c=创建 s=索引
gcc main.c -L. -ladd -o app        # 链接: 找 libadd.a

gcc -c -fPIC add.c -o add.o        # -fPIC 位置无关代码
gcc -shared -o libadd.so add.o
gcc main.c -L. -ladd -o app
./app                              # 可能报找不到 libadd.so
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH   # 运行时搜索路径
# 或编译时写死 rpath: gcc main.c -L. -ladd -Wl,-rpath,$PWD
ldconfig                           # 更新系统共享库缓存 /etc/ld.so.conf
ldd app                            # 查看依赖的动态库

#include <sched.h>
#include <unistd.h>
#include <cstdio>
int main() {
    // 查看调度策略
    int policy = sched_getscheduler(0);
    printf("policy: %d (0=OTHER,1=FIFO,2=RR)\n", policy);

    // 设置为 RR 实时调度（需 root 权限）
    struct sched_param sp; sp.sched_priority = 50;
    sched_setscheduler(0, SCHED_RR, &sp);

    // 修改 nice 值（普通进程，-20 最高优先级）
    nice(-5);
    return 0;
}

#include <unistd.h>
#include <sys/syscall.h>
#include <cstdio>
int main() {
    // 直接发起系统调用（glibc 的 write 底层就是它）
    syscall(SYS_write, 1, "hello\n", 6);
    return 0;
}

strace -e trace=write ./app   # 观察 write 系统调用
cat /proc/sys/kernel/        # 内核参数

#include <atomic>
std::atomic<int> data{0};
std::atomic<bool> ready{false};

// 写线程
void producer() {
    data.store(42, std::memory_order_relaxed);
    ready.store(true, std::memory_order_release);  // release：前面的写对后续可见
}
// 读线程
void consumer() {
    while (!ready.load(std::memory_order_acquire)) {} // acquire
    int v = data.load(std::memory_order_relaxed);      // 保证读到 42
}

// 编译器屏障（阻止编译器重排，非 CPU 屏障）
asm volatile("" ::: "memory");
// x86 上 CPU 屏障指令：mfence（全屏障）、lfence（读）、sfence（写）
__sync_synchronize();   // GCC 内建全屏障

# Makefile
CC = g++
CFLAGS = -O2
app: main.o add.o
	$(CC) -o app main.o add.o
main.o: main.cpp add.h
	$(CC) $(CFLAGS) -c main.cpp
add.o: add.cpp add.h
	$(CC) $(CFLAGS) -c add.cpp
clean:
	rm -f *.o app

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(demo CXX)
add_executable(app main.cpp add.cpp)   # 自动处理依赖
target_compile_options(app PRIVATE -O2)

make -j8              # 并行构建
# CMake 常用流程
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j8

touch a.txt
ls -i a.txt            # 查看 inode 号（第一列）
stat a.txt             # 查看完整 inode 元数据

ln a.txt a_hard.txt    # 硬链接：链接数 +1，同一 inode
ln -s a.txt a_soft.txt # 软链接：新建 inode，指向 "a.txt"

ls -li a.txt a_hard.txt a_soft.txt   # 对比 inode 号与链接数
rm a.txt               # 删除原文件后：硬链接仍可读，软链接悬空

// POSIX 共享内存
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstdio>
#include <cstring>

int main() {
    const char* name = "/my_shm";
    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, 4096);                       // 先定大小
    char* p = (char*)mmap(nullptr, 4096, PROT_READ | PROT_WRITE,
                          MAP_SHARED, fd, 0);  // 映射到本进程地址空间
    strcpy(p, "hello from producer");
    printf("written: %s\n", p);

    munmap(p, 4096);
    close(fd);
    shm_unlink(name);                          // 删除共享内存对象
    return 0;
}

#include <semaphore.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <cstdio>
#include <cstring>
#include <unistd.h>

int main() {
    sem_t* sem = sem_open("/my_sem", O_CREAT, 0666, 1); // 初始值 1 = 互斥
    int fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
    ftruncate(fd, 4096);
    char* p = (char*)mmap(nullptr, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    sem_wait(sem);               // P 操作：值-1，为 0 则阻塞
    strcpy(p, "critical data");  // 临界区：多个进程互斥访问
    sem_post(sem);               // V 操作：值+1，唤醒等待者

    munmap(p, 4096);
    close(fd);
    sem_close(sem);
    sem_unlink("/my_sem");
    shm_unlink("/my_shm");
    return 0;
}

CPU 发出虚拟地址
   │
   ▼
查 TLB ──命中(hit)──→ 直接得物理地址 → 访问内存
   │未命中(miss)
   ▼
查多级页表(PGD→P4D→PUD→PMD→PTE) → 更新 TLB → 访问内存

#include <unistd.h>
#include <cstdio>
int main() {
    // MMU 分页基本单位（通常 4KB）
    printf("page size = %ld\n", sysconf(_SC_PAGESIZE));
    return 0;
}

#define _GNU_SOURCE
#include <sched.h>
#include <cstdio>

int main() {
    cpu_set_t set;
    CPU_ZERO(&set);
    CPU_SET(2, &set);                       // 绑定到 CPU 2
    sched_setaffinity(0, sizeof(set), &set);

    cpu_set_t get;
    CPU_ZERO(&get);
    sched_getaffinity(0, sizeof(get), &get);
    printf("CPU2 是否在亲和集内: %d\n", CPU_ISSET(2, &get));
    return 0;
}

taskset -c 0,2 ./app            # 让 app 只在 CPU 0、2 上跑
taskset -pc 1234                # 查看进程 1234 的亲和性
numactl --hardware              # 查看 NUMA 拓扑（几个 node、各 node 内存）
numactl --cpunodebind=0 --membind=0 ./app   # 绑定到 node 0 的 CPU 与本地内存

  新建 ──→ 就绪 ──→ 运行 ──→ 终止
              ↑       │
              └── 阻塞 ←┘

ps aux                # STAT 列看状态
ps -eo pid,stat,comm  # 自定义输出
top                   # 实时查看 R/S/D 等

#include <unistd.h>
int main() {
    pid_t pid = fork();
    if (pid == 0) { while(1) sleep(10); }  // 子进程：S（可中断睡眠）
    else          { while(1) {} }          // 父进程：R（忙等占 CPU）
}

#include <pthread.h>
#include <cstdio>
void* run(void*) {
    printf("线程 %lu 运行\n", (unsigned long)pthread_self());
    return nullptr;
}
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, nullptr, run, nullptr);
    pthread_create(&t2, nullptr, run, nullptr);
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    return 0;
}

ps -eLf     # -L 显示每个线程
top -H      # 按线程查看

vmstat 1                          # cs 列 = 每秒上下文切换次数
pidstat -w 1                      # cswch(自愿)/nvcswch(非自愿) 切换
perf stat -e context-switches ./app

// 概念对照：频繁 fork 进程的切换开销，远大于线程池内线程切换
// 高并发场景应尽量用线程/协程，减少进程级上下文切换

// 多线程（线程池）示例
#include <thread>
#include <vector>
#include <cstdio>
int main() {
    std::vector<std::thread> pool;
    for (int i = 0; i < 8; ++i)
        pool.emplace_back([i]{ printf("worker %d\n", i); });
    for (auto& t : pool) t.join();
    return 0;
}

#include <cstdio>

// 不可重入：使用静态缓冲区，多次进入会互相覆盖
char* not_reentrant(int x) {
    static char buf[32];
    snprintf(buf, sizeof(buf), "%d", x);
    return buf;
}

// 可重入：缓冲区由调用者提供，或使用局部变量
char* reentrant(int x, char* buf, size_t len) {
    snprintf(buf, len, "%d", x);
    return buf;
}

// 线程安全但不一定可重入：用互斥锁保护全局变量
#include <mutex>
int counter = 0;
std::mutex m;
void safe_increment() {
    std::lock_guard<std::mutex> lock(m);
    ++counter;
}

#include <unistd.h>
#include <cstdlib>
#include <fcntl.h>

void daemonize() {
    pid_t pid = fork();
    if (pid < 0) exit(1);
    if (pid > 0) _exit(0);           // 1. 父进程退出

    if (setsid() < 0) exit(1);       // 2. 新会话，脱离终端

    pid = fork();
    if (pid < 0) exit(1);
    if (pid > 0) _exit(0);           // 3. 孙进程不是会话首进程

    chdir("/");                      // 4. 改工作目录
    umask(0);                        // 5. 重置权限掩码

    int fd = open("/dev/null", O_RDWR);  // 6. 重定向标准 IO
    dup2(fd, 0); dup2(fd, 1); dup2(fd, 2);
    if (fd > 2) close(fd);
}

int main() {
    daemonize();
    while (1) {
        // 后台服务逻辑
        sleep(10);
    }
    return 0;
}

ps -eo pid,ppid,stat,cmd | grep -E 'sshd|nginx|cron'   # 观察 daemon：PPID=1、无 TTY
systemctl status nginx                                # systemd 管理的守护进程