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

wufei123 2025-01-26 阅读:38 评论:0

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

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

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

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

1. 同步：

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

实战案例：

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

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

// 共享变量
int counter = 0;

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

int main() {
    // 创建互斥锁
    pthread_mutex_t lock;
    pthread_mutex_init(&amp;lock, NULL);
    
    // 创建线程
    pthread_t threads[4];
    for (int i = 0; i <p>在这个例子中，四个线程并发地增加 counter 变量。互斥锁确保在同一时间只有一个线程可以访问共享变量，防止出现竞态条件。</p>
<p><strong>2. 通信：</strong></p>
<ul>
<li>
<strong>目的：</strong>允许线程之间交换信息和协调活动。</li>
<li>
<strong>方法：</strong>使用信号 (pthread_cond_t)、共享内存和管道。</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(&amp;buffer-&gt;lock);
        while (buffer-&gt;tail == (buffer-&gt;head + 1) % 10) {
            // 满了，等待消费者消费
            pthread_cond_wait(&amp;buffer-&gt;full, &amp;buffer-&gt;lock);
        }
        
        // 没满，生产
        buffer-&gt;buffer[buffer-&gt;tail] = rand() % 100;
        buffer-&gt;tail = (buffer-&gt;tail + 1) % 10;
        
        // 生产完成后，通知消费者消费
        pthread_cond_signal(&amp;buffer-&gt;empty);
        pthread_mutex_unlock(&amp;buffer-&gt;lock);
    }
    
    return NULL;
}

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

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