C语言多线程编程：同步与通信问题解答-C++-PHP中文网

同步和通信是多线程编程中关键的概念，用于确保线程协作和数据一致性。1. 同步：目的：防止线程访问共享数据时发生竞态条件。方法：使用互斥锁、条件变量和原子变量。2. 通信：目的：允许线程交换信息并协调活动。方法：使用信号、共享内存和管道。

C语言多线程编程：同步与通信问题解答

C语言多线程编程：同步与通信问题解答

在多线程编程中，同步和通信是至关重要的概念，用于确保线程之间协作和数据一致性。本文将详细探讨这两个概念，并提供实战案例，以帮助你理解和解决多线程编程中的常见问题。

1. 同步：

目的：防止线程访问共享数据时发生竞态条件和不一致性。
方法：使用互斥锁 (pthread_mutex_t)、条件变量 (pthread_cond_t) 和原子变量（如 pthread_atomic_t）。

实战案例：

考虑以下代码，它使用互斥锁来同步对共享变量 counter 的访问：

Multi-Brain Protocol

一款AI工具，主要用于在主代理响应前，并行运行Kimi K2.5和GPT 5.3 Codex，注入双方观点以增强认知多样性，适合需要提升相关任务效率的用户。

下载

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

// 共享变量
int counter = 0;

// 线程函数
void* increment_counter(void *arg) {
    // 获取互斥锁
    pthread_mutex_lock(&lock);
    
    // 增加计数器
    counter++;
    
    // 释放互斥锁
    pthread_mutex_unlock(&lock);
    
    return NULL;
}

int main() {
    // 创建互斥锁
    pthread_mutex_t lock;
    pthread_mutex_init(&lock, NULL);
    
    // 创建线程
    pthread_t threads[4];
    for (int i = 0; i <p>在这个例子中，四个线程并发地增加 <code>counter</code> 变量。互斥锁确保在同一时间只有一个线程可以访问共享变量，防止出现竞态条件。</p>
<p><strong>2. 通信：</strong></p>
<ul>
<li>
<strong>目的：</strong>允许线程之间交换信息和协调活动。</li>
<li>
<strong>方法：</strong>使用信号 (<code>pthread_cond_t</code>)、共享内存和管道。</li>
</ul>
<p><strong>实战案例：</strong></p>
<p>考虑以下使用条件变量来实现生产者-消费者模型的代码：</p>
<pre class="brush:c;toolbar:false;">#include <pthread.h>
#include <stdio.h>

// 生产者-消费者模型
typedef struct {
    int buffer[10];
    int head;
    int tail;
    pthread_mutex_t lock;
    pthread_cond_t full;
    pthread_cond_t empty;
} buffer_t;

// 生产者线程
void* producer(void *arg) {
    buffer_t *buffer = (buffer_t *)arg;
    
    while (1) {
        // 先获取锁，再判断是否满了
        pthread_mutex_lock(&buffer->lock);
        while (buffer->tail == (buffer->head + 1) % 10) {
            // 满了，等待消费者消费
            pthread_cond_wait(&buffer->full, &buffer->lock);
        }
        
        // 没满，生产
        buffer->buffer[buffer->tail] = rand() % 100;
        buffer->tail = (buffer->tail + 1) % 10;
        
        // 生产完成后，通知消费者消费
        pthread_cond_signal(&buffer->empty);
        pthread_mutex_unlock(&buffer->lock);
    }
    
    return NULL;
}

// 消费者线程
void* consumer(void *arg) {
    buffer_t *buffer = (buffer_t *)arg;
    
    while (1) {
        // 先获取锁，再判断是否为空
        pthread_mutex_lock(&buffer->lock);
        while (buffer->head == buffer->tail) {
            // 空了，等待生产者生产
            pthread_cond_wait(&buffer->empty, &buffer->lock);
        }
        
        // 没空，消费
        int item = buffer->buffer[buffer->head];
        buffer->head = (buffer->head + 1) % 10;
        
        // 消费完成后，通知生产者生产
        pthread_cond_signal(&buffer->full);
        pthread_mutex_unlock(&buffer->lock);
        
        printf("Consumed: %d\n", item);
    }
    
    return NULL;
}

int main() {
    // 初始化缓冲区
    buffer_t buffer;
    buffer.head = 0;
    buffer.tail = 0;
    pthread_mutex_init(&buffer.lock, NULL);
    pthread_cond_init(&buffer.full, NULL);
    pthread_cond_init(&buffer.empty, NULL);
    
    // 创建线程
    pthread_t producer_thread, consumer_thread;
    pthread_create(&producer_thread, NULL, producer, &buffer);
    pthread_create(&consumer_thread, NULL, consumer, &buffer);
    
    // 等待线程完成
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    
    return 0;
}</stdio.h></pthread.h>

在这个例子中，条件变量 full 和 empty 用于协调生产者和消费者线程。生产者线程在生产完成后通知消费者消费，而消费者线程在消费完成后通知生产者生产。