操作系统中，线程通信的方法、手段

在操作系统中，线程通信是多线程编程的重要组成部分，目的是为了在多个线程之间安全、有效地共享数据和协调工作。以下是操作系统中线程通信的常见方法及其应用场景：

🌐 1. 共享内存 (Shared Memory)

🔹 原理：

• 多个线程共享同一进程的地址空间，通过全局变量、静态变量、堆内存等方式实现数据共享。
• 线程通过同步机制（如互斥锁、信号量）来保证数据一致性。

🔹 常用工具：

✅ Mutex（互斥锁） — 防止数据竞争，保证同一时刻仅有一个线程访问共享数据。
✅ Read-Write Lock（读写锁） — 允许多个线程同时读，但只允许一个线程写。

🔹 示例代码 (C - pthread + Mutex)

#include <pthread.h>
#include <stdio.h>

int counter = 0; // 共享资源
pthread_mutex_t mutex; // 创建互斥锁

void* increment(void* arg) {
    for(int i = 0; i < 100000; ++i) {
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;

    pthread_mutex_init(&mutex, NULL);

    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("最终计数值: %d\n", counter);  // 200000（线程安全）
    pthread_mutex_destroy(&mutex);

    return 0;
}

📩 2. 信号量 (Semaphore)

🔹 原理：

• 信号量是一个计数器，控制对共享资源的访问，支持多个线程同时访问。
• 信号量值：
  • >0 → 可访问资源
  • =0 → 线程阻塞，等待资源释放

🔹 常用场景：

✅ 控制线程数目（如限制最多 5 个线程访问某个资源）
✅ 生产者-消费者模型

🔹 示例代码 (C - sem_t)

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>

sem_t semaphore;

void* threadFunc(void* arg) {
    sem_wait(&semaphore);  // 获取信号量
    printf("线程 %ld 正在访问共享资源\n", pthread_self());
    sleep(1);
    printf("线程 %ld 释放资源\n", pthread_self());
    sem_post(&semaphore);  // 释放信号量
    return NULL;
}

int main() {
    pthread_t threads[3];

    sem_init(&semaphore, 0, 2);  // 最多允许2个线程同时访问

    for(int i = 0; i < 3; i++)
        pthread_create(&threads[i], NULL, threadFunc, NULL);

    for(int i = 0; i < 3; i++)
        pthread_join(threads[i], NULL);

    sem_destroy(&semaphore);
    return 0;
}

🔄 3. 条件变量 (Condition Variable)

🔹 原理：

• 条件变量用于线程间的等待和通知机制。
• 常与 pthread_mutex 配合使用。

🔹 常用场景：

✅ 生产者-消费者模型
✅ 线程间的事件通知

🔹 示例代码 (C - pthread_cond)

#include <pthread.h>
#include <stdio.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
int ready = 0;

void* producer(void* arg) {
    pthread_mutex_lock(&mutex);
    ready = 1;  // 数据已准备好
    printf("生产者：数据已准备好\n");
    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("消费者：已接收数据\n");
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    pthread_create(&t1, NULL, producer, NULL);
    pthread_create(&t2, NULL, consumer, NULL);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    return 0;
}

📮 4. 管道 (Pipe)

🔹 原理：

• 管道是单向通信机制，允许一个线程将数据写入管道，另一个线程从管道读取数据。
• 在 Linux 中使用 pipe() 系统调用。

🔹 常用场景：

✅ 父子线程/进程之间的数据传递
✅ 处理器和子模块之间的数据流控制

🔹 示例代码 (C - pipe())

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main() {
    int fd[2]; // 创建管道
    char buffer[100];
    
    pipe(fd);  // 创建管道

    if (fork() == 0) {  // 子线程
        close(fd[0]);  // 关闭读端
        write(fd[1], "Hello from child", 17);
    } else {  // 父线程
        close(fd[1]);  // 关闭写端
        read(fd[0], buffer, sizeof(buffer));
        printf("父线程接收到数据: %s\n", buffer);
    }

    return 0;
}

📨 5. 消息队列 (Message Queue)

🔹 原理：

• 消息队列是由内核维护的数据结构，线程通过它传递数据。
• 提供先进先出 (FIFO) 数据流。

🔹 常用场景：

✅ 多线程程序中的数据缓冲
✅ 高并发场景下的数据分发

🔹 示例代码 (Linux - mq_send, mq_receive)

#include <stdio.h>
#include <mqueue.h>
#include <string.h>

#define QUEUE_NAME "/my_queue"

int main() {
    mqd_t mq = mq_open(QUEUE_NAME, O_CREAT | O_WRONLY, 0644, NULL);
    const char* message = "Hello, Message Queue!";
    mq_send(mq, message, strlen(message) + 1, 0);
    mq_close(mq);
    return 0;
}

📋 对比总结

推荐学习路径

✅ 初学者推荐使用 共享内存 + 互斥锁（最直观）
✅ 并发模型复杂时推荐使用 信号量 和 条件变量（更灵活）
✅ 大规模数据通信推荐 消息队列（更高效）