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

#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 < 4; i++) {
        pthread_create(&threads[i], NULL, increment_counter, NULL);
    }
    
    // 等待线程完成
    for (int i = 0; i < 4; i++) {
        pthread_join(threads[i], NULL);
    }
    
    // 打印最终计数
    printf("Final counter value: %d\n", counter);
    
    return 0;
}

#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;
}