1. 线程与进程通信的核心概念
在Linux系统中，线程和进程是程序执行的基本单位。进程是资源分配的最小单位，而线程是CPU调度的最小单位。一个进程可以包含多个线程，这些线程共享进程的资源（如内存空间、文件描述符等），但每个线程有自己的栈和寄存器状态。
进程间通信（IPC）是指不同进程之间传递数据或信号的机制。由于进程拥有独立的地址空间，操作系统需要提供专门的机制来实现这种通信。而线程间通信则相对简单，因为它们共享相同的地址空间，可以直接通过共享变量进行交互。
注意：虽然线程可以直接访问共享内存，但必须使用同步机制（如互斥锁）来避免竞态条件，否则可能导致数据不一致。
2. 线程间通信的主要方法
2.1 共享内存
线程间最直接的通信方式就是通过共享变量。由于同一进程的所有线程共享相同的内存空间，一个线程可以直接读写另一个线程可见的全局变量或堆内存。
c复制#include <pthread.h>
#include <stdio.h>
int shared_var = 0;
void* thread_func(void* arg) {
for (int i = 0; i < 100000; i++) {
shared_var++;
}
return NULL;
}
int main() {
pthread_t t1, t2;
pthread_create(&t1, NULL, thread_func, NULL);
pthread_create(&t2, NULL, thread_func, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("Final value: %d\n", shared_var);
return 0;
}
这个简单的例子展示了两个线程共享一个全局变量。然而，这个实现存在严重问题：对shared_var的递增操作不是原子性的，可能导致竞态条件。
2.2 互斥锁（Mutex）
为了解决共享内存的同步问题，我们需要使用互斥锁：
c复制#include <pthread.h>
#include <stdio.h>
int shared_var = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_func(void* arg) {
for (int i = 0; i < 100000; i++) {
pthread_mutex_lock(&mutex);
shared_var++;
pthread_mutex_unlock(&mutex);
}
return NULL;
}
// main函数同上
现在，每次对shared_var的修改都被互斥锁保护，确保了操作的原子性。
2.3 条件变量（Condition Variables）
条件变量用于线程间的通知机制，允许线程等待某个条件成立：
c复制#include <pthread.h>
#include <stdio.h>
int ready = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* producer(void* arg) {
pthread_mutex_lock(&mutex);
ready = 1;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
return NULL;
}
void* consumer(void* arg) {
pthread_mutex_lock(&mutex);
while (!ready) {
pthread_cond_wait(&cond, &mutex);
}
printf("Data is ready\n");
pthread_mutex_unlock(&mutex);
return NULL;
}
这个例子展示了典型的生产者-消费者模式，生产者线程设置ready标志并通知消费者线程。
3. 进程间通信的主要方法
3.1 管道（Pipe）
管道是最简单的进程间通信方式，它提供一个单向的数据流：
c复制#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
int main() {
int fd[2];
pipe(fd);
if (fork() == 0) { // 子进程
close(fd[0]); // 关闭读端
write(fd[1], "Hello", 6);
close(fd[1]);
return 0;
} else { // 父进程
close(fd[1]); // 关闭写端
char buf[10];
read(fd[0], buf, 10);
printf("Received: %s\n", buf);
close(fd[0]);
wait(NULL);
}
return 0;
}
管道的特点：
- 单向通信
- 只能用于有亲缘关系的进程
- 数据是字节流，没有消息边界
3.2 命名管道（FIFO）
命名管道解决了普通管道只能用于亲缘进程的问题：
bash复制# 创建一个命名管道
mkfifo myfifo
# 进程1写入数据
echo "Hello" > myfifo
# 进程2读取数据
cat < myfifo
在程序中，命名管道的使用与普通文件类似，通过open/read/write等系统调用操作。
3.3 共享内存
共享内存是最快的IPC方式，允许多个进程访问同一块内存区域：
c复制#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
int main() {
// 创建共享内存段
int shmid = shmget(IPC_PRIVATE, 1024, 0666|IPC_CREAT);
// 附加到当前进程地址空间
char* shm = (char*)shmat(shmid, NULL, 0);
sprintf(shm, "Hello from process");
// 分离共享内存
shmdt(shm);
// 另一个进程可以通过相同的shmid访问这块内存
// 最后需要删除共享内存段
shmctl(shmid, IPC_RMID, NULL);
return 0;
}
注意：共享内存不提供任何同步机制，通常需要配合信号量使用。
3.4 消息队列
消息队列允许进程以消息的形式交换数据：
c复制#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
struct msg_buffer {
long msg_type;
char msg_text[100];
};
int main() {
key_t key = ftok("progfile", 65);
int msgid = msgget(key, 0666 | IPC_CREAT);
struct msg_buffer message;
message.msg_type = 1;
strcpy(message.msg_text, "Hello Message Queue");
// 发送消息
msgsnd(msgid, &message, sizeof(message), 0);
// 接收消息
msgrcv(msgid, &message, sizeof(message), 1, 0);
printf("Received: %s\n", message.msg_text);
// 删除消息队列
msgctl(msgid, IPC_RMID, NULL);
return 0;
}
消息队列的特点：
- 消息有类型，可以按类型接收
- 消息边界被保留
- 不需要进程间有亲缘关系
3.5 信号量
信号量用于进程间的同步：
c复制#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
int main() {
key_t key = ftok("semfile", 65);
int semid = semget(key, 1, 0666 | IPC_CREAT);
// 初始化信号量值为1
semctl(semid, 0, SETVAL, 1);
struct sembuf op;
op.sem_num = 0;
op.sem_op = -1; // P操作（获取）
op.sem_flg = 0;
semop(semid, &op, 1);
printf("Critical section\n");
op.sem_op = 1; // V操作（释放）
semop(semid, &op, 1);
return 0;
}
4. 通信方式的选择与性能比较
4.1 性能比较
下表比较了不同IPC方式的性能特点：
| 通信方式 | 速度 | 容量 | 适用范围 | 同步机制 |
|---|---|---|---|---|
| 管道 | 中等 | 有限 | 亲缘进程 | 内核自动同步 |
| 命名管道 | 中等 | 有限 | 任意进程 | 内核自动同步 |
| 共享内存 | 最快 | 大 | 任意进程 | 需要额外同步 |
| 消息队列 | 较慢 | 中等 | 任意进程 | 内置消息边界 |
| 信号量 | 快 | - | 同步控制 | 本身就是同步 |
4.2 选择指南
- 线程间通信：优先考虑共享内存+互斥锁/条件变量
- 大量数据传输：考虑共享内存
- 简单消息通知：管道或消息队列
- 需要同步：信号量
- 无亲缘关系进程：命名管道、消息队列或共享内存
5. 常见问题与调试技巧
5.1 死锁问题
死锁是多线程/多进程编程中最常见的问题之一。典型场景：
- 线程A持有锁1，请求锁2
- 线程B持有锁2，请求锁1
解决方法：
- 总是以相同的顺序获取锁
- 使用trylock而非lock，设置超时
- 使用工具如helgrind检测死锁
5.2 竞态条件
竞态条件指程序的行为依赖于事件执行的时序。调试技巧：
- 使用ThreadSanitizer工具检测数据竞争
- 增加日志输出，记录关键操作的顺序
- 设计可重复的测试用例
5.3 共享内存问题
常见问题包括：
- 忘记同步访问
- 指针在不同进程中无效
- 内存泄漏
调试建议：
- 使用ipcs命令查看共享内存状态
- 为共享内存区域设计清晰的访问协议
- 使用mmap替代System V共享内存（更灵活）
5.4 性能优化技巧
- 减少锁的粒度：使用更细粒度的锁而非全局锁
- 读写锁：当读多写少时，使用pthread_rwlock_t
- 无锁编程：在特定场景下使用原子操作
- 避免虚假唤醒：使用while而非if检查条件变量
c复制// 正确使用条件变量的方式
pthread_mutex_lock(&mutex);
while (!condition) {
pthread_cond_wait(&cond, &mutex);
}
// 操作共享数据
pthread_mutex_unlock(&mutex);
6. 实际应用案例
6.1 多线程Web服务器
一个典型的多线程Web服务器会：
- 主线程监听端口，接受连接
- 为每个新连接创建线程处理请求
- 使用线程池避免频繁创建销毁线程
- 共享数据结构存储会话信息
关键点：
- 使用互斥锁保护共享的连接队列
- 条件变量通知工作线程有新任务
- 精心设计线程退出机制
6.2 多进程数据处理系统
一个数据处理系统可能：
- 主进程管理任务队列
- 多个工作进程处理数据
- 使用共享内存存储中间结果
- 消息队列传递任务信息
设计考虑：
- 进程崩溃不影响整体系统
- 任务分配均衡
- 结果收集机制
6.3 生产者-消费者模式
这是最常用的并发模式之一：
c复制#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
void* producer(void* arg) {
for (int i = 0; i < 100; i++) {
pthread_mutex_lock(&mutex);
while (count == BUFFER_SIZE) {
pthread_cond_wait(&cond_producer, &mutex);
}
buffer[count++] = i;
pthread_cond_signal(&cond_consumer);
pthread_mutex_unlock(&mutex);
}
return NULL;
}
void* consumer(void* arg) {
for (int i = 0; i < 100; i++) {
pthread_mutex_lock(&mutex);
while (count == 0) {
pthread_cond_wait(&cond_consumer, &mutex);
}
printf("Consumed: %d\n", buffer[--count]);
pthread_cond_signal(&cond_producer);
pthread_mutex_unlock(&mutex);
}
return NULL;
}
这个实现展示了如何正确使用条件变量实现生产者-消费者模式。