🧵 进程与线程模型面试题

        fork()
          ↓
       ┌─────┐
       │ 新建 │
       └──┬──┘
          ↓ 就绪
       ┌─────┐      调度      ┌─────┐
    ┌→ │ 就绪 │ ──────────→  │ 运行 │
    │  └─────┘               └──┬──┘
    │     ↑                     │
    │     │ 时间片用完/被抢占     │
    │     └─────────────────────┘
    │     ↑
    │     │ I/O 完成/事件发生
    │  ┌─────┐
    └─ │ 阻塞 │ ←─── I/O 请求/等待事件
       └─────┘
          ↑
          │
       ┌─────┐
       │ 运行 │ ──→ exit() ──→ 终止
       └─────┘

int pipefd[2];
pipe(pipefd);  // pipefd[0] 读端，pipefd[1] 写端

if (fork() == 0) {
    // 子进程：写数据
    close(pipefd[0]);
    write(pipefd[1], "Hello", 5);
    close(pipefd[1]);
} else {
    // 父进程：读数据
    close(pipefd[1]);
    char buf[10];
    read(pipefd[0], buf, 5);
    close(pipefd[0]);
}

// 创建共享内存
int shmid = shmget(IPC_PRIVATE, 1024, 0666 | IPC_CREAT);

// 映射到进程地址空间
char *shmaddr = shmat(shmid, NULL, 0);

// 写入数据
strcpy(shmaddr, "Hello");

// 读取数据（另一个进程）
printf("%s\n", shmaddr);

// 解除映射
shmdt(shmaddr);

// 创建消息队列
int msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);

// 发送消息
struct msgbuf {
    long mtype;
    char mtext[100];
};
struct msgbuf msg = {1, "Hello"};
msgsnd(msgid, &msg, sizeof(msg.mtext), 0);

// 接收消息
msgrcv(msgid, &msg, sizeof(msg.mtext), 1, 0);

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    // 临界区：访问共享资源
    shared_counter++;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

sem_t sem;
sem_init(&sem, 0, 3);  // 初始值为 3，最多 3 个线程同时访问

void* thread_func(void* arg) {
    sem_wait(&sem);  // P 操作，信号量 -1
    // 访问资源
    sem_post(&sem);  // V 操作，信号量 +1
    return NULL;
}

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int buffer[10];
int count = 0;

// 生产者
void* producer(void* arg) {
    pthread_mutex_lock(&mutex);
    while (count == 10) {
        pthread_cond_wait(&cond, &mutex);  // 缓冲区满，等待
    }
    buffer[count++] = produce_item();
    pthread_cond_signal(&cond);  // 通知消费者
    pthread_mutex_unlock(&mutex);
}

// 消费者
void* consumer(void* arg) {
    pthread_mutex_lock(&mutex);
    while (count == 0) {
        pthread_cond_wait(&cond, &mutex);  // 缓冲区空，等待
    }
    int item = buffer[--count];
    pthread_cond_signal(&cond);  // 通知生产者
    pthread_mutex_unlock(&mutex);
}

# Linux 查看系统级上下文切换
vmstat 1
# cs 列：每秒上下文切换次数

# 查看进程级上下文切换
pidstat -w -p  1
# cswch/s：自愿上下文切换（I/O 等待）
# nvcswch/s：非自愿上下文切换（时间片用完）

// 方法 1：父进程调用 wait() 回收子进程
pid_t pid = fork();
if (pid == 0) {
    // 子进程
    exit(0);
} else {
    // 父进程
    wait(NULL);  // 阻塞等待子进程结束
}

// 方法 2：使用 SIGCHLD 信号处理
void sigchld_handler(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0);  // 非阻塞回收
}
signal(SIGCHLD, sigchld_handler);

// 方法 3：两次 fork()，让孙子进程成为孤儿进程
if (fork() == 0) {
    if (fork() == 0) {
        // 孙子进程，父进程立即退出，由 init 回收
        sleep(10);
        exit(0);
    }
    exit(0);  // 子进程立即退出
}
wait(NULL);  // 回收子进程

# 查看僵尸进程
ps aux | grep Z
# 或
ps -eo pid,ppid,stat,cmd | grep Z

# 查看僵尸进程数量
ps aux | grep Z | wc -l

# 杀死僵尸进程的父进程（僵尸进程无法直接 kill）
kill -9 <父进程PID>

// 问题代码
class Counter {
    private int count = 0;
    public void increment() {
        count++;  // 非原子操作：读取 -> 加 1 -> 写回
    }
}

// 解决方案 1：synchronized
public synchronized void increment() {
    count++;
}

// 解决方案 2：AtomicInteger
private AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet();
}

// 问题代码
synchronized(lockA) {
    synchronized(lockB) {
        // 线程 1
    }
}

synchronized(lockB) {
    synchronized(lockA) {
        // 线程 2：可能死锁
    }
}

// 解决方案：按固定顺序获取锁
synchronized(lockA) {
    synchronized(lockB) {
        // 所有线程都按 A -> B 顺序
    }
}

// 问题代码
class Task {
    private boolean stop = false;
    
    public void run() {
        while (!stop) {
            // 可能永远看不到 stop 的变化
        }
    }
    
    public void stop() {
        stop = true;
    }
}

// 解决方案：使用 volatile
private volatile boolean stop = false;

// 问题代码
class Counter {
    long count1;  // 可能在同一缓存行
    long count2;
}

// 解决方案：缓存行填充
class Counter {
    long count1;
    long p1, p2, p3, p4, p5, p6, p7;  // 填充到不同缓存行
    long count2;
}

G（Goroutine）：用户态线程
M（Machine）：内核线程
P（Processor）：调度器

         P1              P2
         ↓               ↓
    G1 G2 G3        G4 G5 G6
         ↓               ↓
         M1              M2
         ↓               ↓
      内核线程         内核线程

// 传统线程
Thread thread = new Thread(() -> {
    // 任务
});
thread.start();

// 虚拟线程（Java 19+）
Thread.startVirtualThread(() -> {
    // 任务
});

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,      // 核心线程数
    maximumPoolSize,   // 最大线程数
    keepAliveTime,     // 空闲线程存活时间
    TimeUnit.SECONDS,
    workQueue,         // 任务队列
    threadFactory,     // 线程工厂
    rejectedHandler    // 拒绝策略
);

1. 提交任务
   ↓
2. 核心线程数未满？
   是 → 创建核心线程执行
   否 → 继续
   ↓
3. 队列未满？
   是 → 加入队列等待
   否 → 继续
   ↓
4. 最大线程数未满？
   是 → 创建非核心线程执行
   否 → 执行拒绝策略

// CPU 密集型：图像处理
int cpuCount = Runtime.getRuntime().availableProcessors();
ExecutorService cpuPool = Executors.newFixedThreadPool(cpuCount + 1);

// I/O 密集型：HTTP 请求
ExecutorService ioPool = Executors.newFixedThreadPool(cpuCount * 2);

// 混合型：根据实际测试调整
ThreadPoolExecutor mixedPool = new ThreadPoolExecutor(
    10,                           // 核心线程数
    50,                           // 最大线程数
    60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000),
    new ThreadPoolExecutor.CallerRunsPolicy()
);

ThreadPoolExecutor executor = ...;

// 监控指标
executor.getActiveCount();      // 活跃线程数
executor.getPoolSize();         // 当前线程数
executor.getQueue().size();     // 队列中任务数
executor.getCompletedTaskCount(); // 已完成任务数

# 协程执行流程
协程 A                协程 B
  ↓                     ↓
执行代码              等待
  ↓                     ↓
遇到 I/O，主动让出      ↓
  ↓ ─────────────→   获得执行权
等待                 执行代码
  ↓                     ↓
  ↓                  遇到 I/O，主动让出
  ↓ ←─────────────   等待
获得执行权              ↓
  ↓                     ↓
继续执行              等待

import asyncio

async def fetch_data(url):
    print(f"开始请求 {url}")
    await asyncio.sleep(1)  # 模拟 I/O，主动让出
    print(f"完成请求 {url}")
    return f"Data from {url}"

async def main():
    # 并发执行多个协程
    tasks = [
        fetch_data("url1"),
        fetch_data("url2"),
        fetch_data("url3")
    ]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

# 输出：
# 开始请求 url1
# 开始请求 url2
# 开始请求 url3
# (1 秒后)
# 完成请求 url1
# 完成请求 url2
# 完成请求 url3

package main

import (
    "fmt"
    "time"
)

func fetchData(url string, ch chan string) {
    fmt.Printf("开始请求 %s\n", url)
    time.Sleep(1 * time.Second)
    fmt.Printf("完成请求 %s\n", url)
    ch <- fmt.Sprintf("Data from %s", url)
}

func main() {
    ch := make(chan string, 3)
    
    // 启动 3 个协程
    go fetchData("url1", ch)
    go fetchData("url2", ch)
    go fetchData("url3", ch)
    
    // 接收结果
    for i := 0; i < 3; i++ {
        fmt.Println(<-ch)
    }
}