阻塞I/O并发模型：进程与线程

pid_t fork(void);
// 返回值：子进程中返回 0，父进程中返回子进程 PID，出错返回 -1

if (fork() == 0) {
    do_child_process();  // 子进程执行路径
} else {
    do_parent_process(); // 父进程执行路径
}

pid_t wait(int *statloc);              // 阻塞等待任意子进程终止
pid_t waitpid(pid_t pid, int *statloc, int options);  // 支持指定 PID 和 WNOHANG

void sigchld_handler(int sig) {
    while (waitpid(-1, 0, WNOHANG) > 0);  // 循环回收，WNOHANG 非阻塞
}
signal(SIGCHLD, sigchld_handler);

void child_run(int fd) {
    char outbuf[MAX_LINE + 1];
    size_t outbuf_used = 0;
    ssize_t result;
    while (1) {
        char ch;
        result = recv(fd, &ch, 1, 0);
        if (result == 0) break;
        else if (result == -1) break;
        if (outbuf_used < sizeof(outbuf)) outbuf[outbuf_used++] = rot13_char(ch);
        if (ch == '\n') { send(fd, outbuf, outbuf_used, 0); outbuf_used = 0; continue; }
    }
}

int main(int c, char **v) {
    int listener_fd = tcp_server_listen(SERV_PORT);
    signal(SIGCHLD, sigchld_handler);
    while (1) {
        struct sockaddr_storage ss;
        socklen_t slen = sizeof(ss);
        int fd = accept(listener_fd, (struct sockaddr *) &ss, &slen);
        if (fork() == 0) {
            close(listener_fd);   // 子进程关闭监听套接字
            child_run(fd);        // 处理连接
            exit(0);
        } else {
            close(fd);            // 父进程关闭连接套接字
        }
    }
}

void *thread_run(void *arg) {
    pthread_detach(pthread_self());
    int fd = (int)(intptr_t) arg;   // fd 通过 intptr_t 安全转换
    loop_echo(fd);                  // 阻塞 I/O 读写
    return NULL;
}

int main(int c, char **v) {
    int listener_fd = tcp_server_listen(SERV_PORT);
    pthread_t tid;
    while (1) {
        int fd = accept(listener_fd, NULL, NULL);
        if (fd >= 0) {
            pthread_create(&tid, NULL, &thread_run, (void *)(intptr_t) fd);
        }
    }
}

typedef struct {
    int number;              // 容量
    int *fd;                 // 文件描述符数组
    int front, rear;         // 队头/队尾
    pthread_mutex_t mutex;   // 互斥锁
    pthread_cond_t cond;     // 条件变量
} block_queue;

void block_queue_push(block_queue *q, int fd) {
    pthread_mutex_lock(&q->mutex);
    q->fd[q->rear] = fd;
    if (++q->rear == q->number) q->rear = 0;
    pthread_cond_signal(&q->cond);   // 唤醒等待的工作线程
    pthread_mutex_unlock(&q->mutex);
}

int block_queue_pop(block_queue *q) {
    pthread_mutex_lock(&q->mutex);
    while (q->front == q->rear) {          // 队列空则阻塞等待
        pthread_cond_wait(&q->cond, &q->mutex);
    }
    int fd = q->fd[q->front];
    if (++q->front == q->number) q->front = 0;
    pthread_mutex_unlock(&q->mutex);
    return fd;
}