第2周：Linux 进程与线程模型

字数统计: 3.4k字   |   阅读时长≈ 17分

第2周：Linux 进程与线程模型

目标：理解进程生命周期、信号处理、线程同步，能够编写多线程网络服务程序。

1. 进程模型

1.1 fork / exec / waitpid

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(1);
    }
    else if (pid == 0) {
        // === 子进程 ===
        printf("[Child] PID=%d, Parent PID=%d\n", getpid(), getppid());

        // 替换进程映像（exec 系列）
        execlp("ls", "ls", "-la", "/tmp", NULL);

        // 如果 exec 成功，下面代码不会执行
        perror("execlp failed");
        exit(1);
    }
    else {
        // === 父进程 ===
        printf("[Parent] PID=%d, Child PID=%d\n", getpid(), pid);

        int status;
        pid_t wpid = waitpid(pid, &status, 0);  // 阻塞等待子进程

        if (wpid > 0) {
            if (WIFEXITED(status)) {
                printf("[Parent] Child exited with code %d\n", WEXITSTATUS(status));
            }
            if (WIFSIGNALED(status)) {
                printf("[Parent] Child killed by signal %d\n", WTERMSIG(status));
            }
        }
    }

    return 0;
}

fork 之后父子进程的关系：

特性 说明
代码段 共享（只读，通过写时拷贝 COW）
数据段/堆/栈 各自独立（COW，修改时才复制）
文件描述符 共享（指向同一打开文件表项，偏移共享）
PID 不同
返回值 父进程返回子 PID，子进程返回 0

写时拷贝（COW）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int global = 100;  // 全局变量

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程：修改全局变量
        global = 200;
        printf("[Child] global = %d (modified)\n", global);
        exit(0);
    }

    sleep(1);  // 等待子进程修改完成
    printf("[Parent] global = %d (unchanged)\n", global);  // 仍是 100

    return 0;
}

1.2 exec 系列函数

1
2
3
4
5
execl(path, arg0, arg1, ..., NULL)     // 路径 + 参数列表
execv(path, argv)                       // 路径 + 参数数组
execlp(file, arg0, ..., NULL)          // 在 PATH 中搜索
execvp(file, argv)
execve(path, argv, envp)               // 传入环境变量
1
2
3
4
5
6
7
8
9
10
#include <unistd.h>

// 方式1：用环境变量覆盖
char *envp[] = {"PATH=/bin:/usr/bin", "HOME=/tmp", NULL};
execve("/bin/ls", (char *[]){"ls", "-la", NULL}, envp);

// 方式2：修改 environ
extern char **environ;
environ[0] = "PATH=/bin:/usr/bin";
execvp("ls", (char *[]){"ls", "-la", NULL});

1.3 守护进程（Daemon）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <signal.h>

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

    // 2. 创建新会话，脱离终端
    setsid();

    // 3. 防止获取终端控制权
    signal(SIGCHLD, SIG_IGN);
    signal(SIGHUP, SIG_IGN);

    // 4. 二次 fork，防止重新获取终端
    pid = fork();
    if (pid > 0) exit(0);

    // 5. 更改工作目录
    chdir("/");

    // 6. 设置文件权限掩码
    umask(0);

    // 7. 关闭所有文件描述符
    for (int fd = sysconf(_SC_OPEN_MAX); fd >= 0; fd--) {
        close(fd);
    }
}

int main() {
    daemonize();

    // 日志输出到 syslog（略）
    while (1) {
        // 守护进程的主循环
        sleep(60);
    }
    return 0;
}

2. 进程间通信（IPC）

2.1 管道（Pipe）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>

int main() {
    int pipefd[2];
    if (pipe(pipefd) == -1) {
        perror("pipe");
        exit(1);
    }

    pid_t pid = fork();
    if (pid == 0) {
        // 子进程：写入
        close(pipefd[0]);  // 关闭读端
        const char *msg = "Hello from child process!";
        write(pipefd[1], msg, strlen(msg) + 1);
        close(pipefd[1]);
        exit(0);
    }

    // 父进程：读取
    close(pipefd[1]);  // 关闭写端

    char buf[256];
    ssize_t n = read(pipefd[0], buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("[Parent] Received: %s\n", buf);
    }
    close(pipefd[0]);

    wait(NULL);
    return 0;
}

2.2 FIFO（命名管道）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>

#define FIFO_PATH "/tmp/my_fifo"

int main() {
    // 创建命名管道（只执行一次）
    mkfifo(FIFO_PATH, 0666);

    pid_t pid = fork();

    if (pid == 0) {
        // 写入端
        int fd = open(FIFO_PATH, O_WRONLY);
        const char *msg = "Message through FIFO";
        write(fd, msg, strlen(msg) + 1);
        close(fd);
    } else {
        // 读取端
        int fd = open(FIFO_PATH, O_RDONLY);
        char buf[256];
        read(fd, buf, sizeof(buf));
        printf("[Parent] FIFO: %s\n", buf);
        close(fd);

        wait(NULL);
        unlink(FIFO_PATH);  // 删除 FIFO
    }
    return 0;
}

2.3 共享内存（System V + POSIX）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// POSIX 共享内存（推荐）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <sys/wait.h>

#define SHM_NAME "/my_shm"
#define SHM_SIZE 4096

int main() {
    // 创建共享内存对象
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, SHM_SIZE);

    // 映射到进程地址空间
    void *addr = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);

    pid_t pid = fork();
    if (pid == 0) {
        // 子进程写入
        strcpy((char *)addr, "Shared memory data");
        printf("[Child] Written: %s\n", (char *)addr);
        exit(0);
    }

    wait(NULL);

    // 父进程读取（子进程写入的内容）
    printf("[Parent] Read: %s\n", (char *)addr);

    // 清理
    munmap(addr, SHM_SIZE);
    close(fd);
    shm_unlink(SHM_NAME);

    return 0;
}

2.4 信号量（POSIX）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <semaphore.h>
#include <sys/wait.h>

#define SHM_NAME "/sem_shm"

int main() {
    // 创建共享内存存放信号量
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
    ftruncate(fd, sizeof(sem_t));

    sem_t *sem = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);

    // 初始化信号量（值=1，用于互斥）
    sem_init(sem, 1, 1);  // pshared=1 表示进程间共享

    pid_t pid = fork();

    if (pid == 0) {
        sem_wait(sem);  // P 操作（获取锁）
        printf("[Child] Critical section\n");
        sleep(1);
        printf("[Child] Leaving critical section\n");
        sem_post(sem);  // V 操作（释放锁）
        exit(0);
    }

    sleep(0.5);
    sem_wait(sem);
    printf("[Parent] Critical section\n");
    sleep(1);
    printf("[Parent] Leaving critical section\n");
    sem_post(sem);

    wait(NULL);

    sem_destroy(sem);
    munmap(sem, sizeof(sem_t));
    close(fd);
    shm_unlink(SHM_NAME);

    return 0;
}

3. 信号处理

3.1 signal / sigaction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

// 信号处理函数
volatile sig_atomic_t got_signal = 0;

void handler(int sig) {
    got_signal = 1;
    write(STDOUT_FILENO, "Got SIGUSR1!\n", 14);
}

int main() {
    // 注册信号处理函数
    struct sigaction sa = {
        .sa_handler = handler,
        .sa_flags = 0
    };
    sigemptyset(&sa.sa_mask);  // 不屏蔽其他信号

    sigaction(SIGUSR1, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);

    printf("PID: %d\n", getpid());
    printf("Send signal: kill -USR1 %d\n", getpid());

    // 等待信号
    while (!got_signal) {
        pause();  // 挂起直到信号到达
    }

    printf("Resuming after signal\n");
    return 0;
}

3.2 SIGPIPE —— 必须掌握！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>

// SIGPIPE 处理：忽略它，用 write 返回值判断
void setup_sigpipe() {
    signal(SIGPIPE, SIG_IGN);  // 忽略 SIGPIPE
    // 忽略后，向关闭的 socket 写入会返回 EPIPE 错误
}

int main() {
    setup_sigpipe();

    // 写入可能失败的 socket
    ssize_t n = write(fd, data, len);
    if (n < 0) {
        if (errno == EPIPE) {
            printf("Client disconnected\n");
            // 关闭连接
        }
    }

    return 0;
}

SIGPIPE 产生场景：向一个已经被对方关闭的 TCP 连接写入数据时，默认会触发 SIGPIPE 信号导致进程终止。必须忽略 SIGPIPE 并通过 write 的返回值检查 EPIPE。

3.3 信号集与 sigprocmask

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <signal.h>

// 阻塞一组信号
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGINT);   // 阻塞 Ctrl+C
sigaddset(&mask, SIGTERM);

// 应用阻塞
sigprocmask(SIG_BLOCK, &mask, NULL);

// 临界区代码（不会被 SIGINT/SIGTERM 打断）
// ...

// 解除阻塞
sigprocmask(SIG_UNBLOCK, &mask, NULL);

4. 线程模型（pthread）

4.1 基本线程操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

// 线程入口函数
void *worker(void *arg) {
    int id = *(int *)arg;
    printf("[Thread %d] Running on CPU\n", id);
    sleep(1);
    printf("[Thread %d] Done\n", id);
    return NULL;
}

int main() {
    const int N = 4;
    pthread_t threads[N];
    int ids[N];

    // 创建线程
    for (int i = 0; i < N; i++) {
        ids[i] = i;
        int ret = pthread_create(&threads[i], NULL, worker, &ids[i]);
        if (ret != 0) {
            fprintf(stderr, "pthread_create failed: %d\n", ret);
            exit(1);
        }
    }

    // 等待所有线程结束
    for (int i = 0; i < N; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("All threads completed\n");
    return 0;
}

4.2 线程同步

互斥锁（Mutex）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <pthread.h>

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int shared_counter = 0;

void *increment(void *arg) {
    for (int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&lock);   // 加锁
        shared_counter++;
        pthread_mutex_unlock(&lock); // 解锁
    }
    return NULL;
}

// 使用 RAII 风格的自动解锁（避免中途 return 忘记解锁）
typedef struct {
    pthread_mutex_t *mutex;
    int locked;
} LockGuard;

LockGuard lock_guard(pthread_mutex_t *m) {
    LockGuard lg = {m, 0};
    pthread_mutex_lock(m);
    lg.locked = 1;
    return lg;
}

void unlock(LockGuard *lg) {
    if (lg->locked) {
        pthread_mutex_unlock(lg->mutex);
        lg->locked = 0;
    }
}

void *safe_increment(void *arg) {
    LockGuard lg = lock_guard(&lock);
    shared_counter++;
    unlock(&lg);  // 可提前解锁
    return NULL;
}

条件变量（Condition Variable）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ready = 0;

// 消费者线程
void *consumer(void *arg) {
    pthread_mutex_lock(&mutex);
    while (!ready) {
        // 等待条件满足（自动释放 mutex，被唤醒后重新获取）
        pthread_cond_wait(&cond, &mutex);
    }
    printf("[Consumer] Got signal, ready=%d\n", ready);
    pthread_mutex_unlock(&mutex);
    return NULL;
}

// 生产者线程
void *producer(void *arg) {
    sleep(1);
    pthread_mutex_lock(&mutex);
    ready = 1;
    printf("[Producer] Signal ready\n");
    pthread_cond_signal(&cond);  // 唤醒一个等待的线程
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, consumer, NULL);
    pthread_create(&t2, NULL, producer, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}

⚠️ 条件变量使用陷阱：

  • 必须在循环中检查条件（虚假唤醒问题）
  • 必须在 mutex 保护下检查条件
  • pthread_cond_wait 会自动释放 mutex，返回时重新获取

读写锁（RWLock）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <pthread.h>

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
int shared_data = 0;

// 写者（独占）
void *writer(void *arg) {
    pthread_rwlock_wrlock(&rwlock);
    shared_data++;
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

// 读者（共享）
void *reader(void *arg) {
    pthread_rwlock_rdlock(&rwlock);
    printf("Read: %d\n", shared_data);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

4.3 线程安全队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// thread_queue.h
#ifndef THREAD_QUEUE_H
#define THREAD_QUEUE_H

#include <pthread.h>

typedef struct Node {
    void *data;
    struct Node *next;
} Node;

typedef struct {
    Node *head;
    Node *tail;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int size;
} ThreadQueue;

// 创建队列
ThreadQueue *queue_create();

// 销毁队列
void queue_destroy(ThreadQueue *q);

// 入队
void queue_push(ThreadQueue *q, void *data);

// 出队（阻塞）
void *queue_pop(ThreadQueue *q);

// 尝试出队（非阻塞，超时 ms）
void *queue_try_pop(ThreadQueue *q, int timeout_ms);

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// thread_queue.c
#include "thread_queue.h"
#include <stdlib.h>
#include <time.h>

ThreadQueue *queue_create() {
    ThreadQueue *q = malloc(sizeof(ThreadQueue));
    q->head = q->tail = NULL;
    q->size = 0;
    pthread_mutex_init(&q->mutex, NULL);
    pthread_cond_init(&q->cond, NULL);
    return q;
}

void queue_destroy(ThreadQueue *q) {
    Node *cur = q->head;
    while (cur) {
        Node *tmp = cur;
        cur = cur->next;
        free(tmp);
    }
    pthread_mutex_destroy(&q->mutex);
    pthread_cond_destroy(&q->cond);
    free(q);
}

void queue_push(ThreadQueue *q, void *data) {
    Node *node = malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;

    pthread_mutex_lock(&q->mutex);

    if (q->tail) {
        q->tail->next = node;
        q->tail = node;
    } else {
        q->head = q->tail = node;
    }
    q->size++;

    pthread_cond_signal(&q->cond);  // 唤醒等待的消费者
    pthread_mutex_unlock(&q->mutex);
}

void *queue_pop(ThreadQueue *q) {
    pthread_mutex_lock(&q->mutex);

    while (q->size == 0) {
        pthread_cond_wait(&q->cond, &q->mutex);
    }

    Node *node = q->head;
    void *data = node->data;
    q->head = node->next;
    if (q->head == NULL) {
        q->tail = NULL;
    }
    q->size--;
    free(node);

    pthread_mutex_unlock(&q->mutex);
    return data;
}

4.4 线程属性与 detached 状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <pthread.h>

// 创建 detached 线程（不需要 join）
void create_detached_thread(void *(*fn)(void *), void *arg) {
    pthread_t tid;
    pthread_attr_t attr;

    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

    pthread_create(&tid, &attr, fn, arg);
    pthread_attr_destroy(&attr);
    // 不需要 pthread_join
}

// 线程局部存储（TLS / Thread Local Storage）
static __thread int thread_local_var = 0;

void *worker(void *arg) {
    thread_local_var = 42;  // 每个线程独立的副本
    printf("Thread %ld: tls=%d\n", pthread_self(), thread_local_var);
    return NULL;
}

5. 实践：多线程文件传输工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
// mt_transfer.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/stat.h>
#include "thread_queue.h"

#define PORT 8080
#define WORKER_THREADS 4
#define CHUNK_SIZE 8192

// 任务结构
typedef struct {
    int client_fd;
    char filepath[512];
} Task;

// 全局队列
static ThreadQueue *task_queue;

// 发送线程：从队列取出任务，发送文件
void *sender_thread(void *arg) {
    while (1) {
        Task *task = queue_pop(task_queue);

        // 打开文件
        int fd = open(task->filepath, O_RDONLY);
        if (fd < 0) {
            const char *err = "404 Not Found\n";
            write(task->client_fd, err, strlen(err));
            close(task->client_fd);
            free(task);
            continue;
        }

        // 发送 HTTP 响应头
        struct stat st;
        fstat(fd, &st);
        char header[256];
        snprintf(header, sizeof(header),
                 "HTTP/1.1 200 OK\r\n"
                 "Content-Length: %ld\r\n"
                 "Content-Type: application/octet-stream\r\n"
                 "\r\n", st.st_size);
        write(task->client_fd, header, strlen(header));

        // 发送文件内容
        char buf[CHUNK_SIZE];
        ssize_t n;
        while ((n = read(fd, buf, sizeof(buf))) > 0) {
            ssize_t sent = 0;
            while (sent < n) {
                ssize_t w = write(task->client_fd, buf + sent, n - sent);
                if (w <= 0) break;
                sent += w;
            }
        }

        close(fd);
        close(task->client_fd);
        free(task);
    }
    return NULL;
}

// 主线程：监听连接，提交任务到队列
int main() {
    // 创建任务队列
    task_queue = queue_create();

    // 启动工作线程
    pthread_t workers[WORKER_THREADS];
    for (int i = 0; i < WORKER_THREADS; i++) {
        pthread_create(&workers[i], NULL, sender_thread, NULL);
    }

    // 监听 socket（简化，用 TCP）
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(PORT),
        .sin_addr.s_addr = INADDR_ANY
    };
    bind(listen_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(listen_fd, 128);

    printf("Server listening on port %d, %d workers\n", PORT, WORKER_THREADS);

    // 接受连接循环
    while (1) {
        int client_fd = accept(listen_fd, NULL, NULL);
        if (client_fd < 0) continue;

        // 读取 HTTP 请求获取文件名
        char req[1024];
        ssize_t n = read(client_fd, req, sizeof(req) - 1);
        if (n > 0) {
            req[n] = '\0';
            // 简单解析：GET /path HTTP/1.1
            char *start = strchr(req, ' ') + 1;
            char *end = strchr(start, ' ');
            if (end) *end = '\0';

            // 构造任务
            Task *task = malloc(sizeof(Task));
            task->client_fd = client_fd;
            snprintf(task->filepath, sizeof(task->filepath), ".%s", start);

            queue_push(task_queue, task);
        } else {
            close(client_fd);
        }
    }

    close(listen_fd);
    queue_destroy(task_queue);
    return 0;
}
1
2
3
gcc -o mt_transfer mt_transfer.c thread_queue.c -lpthread
./mt_transfer &
curl http://localhost:8080/test.txt

6. 实战要点总结

概念 关键点
fork 父进程返回子 PID，子进程返回 0；COW 机制
exec 替换当前进程映像，不返回（失败才返回）
waitpid 阻塞/非阻塞回收子进程，获取退出状态
信号 异步通知机制；SIGPIPE 必须忽略
Mutex 互斥访问，防止数据竞争
CondVar 等待条件满足，避免忙轮询
线程安全队列 Mutex + CondVar 是标准实现
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870