详解C语言进程同步机制

前言

进程同步是操作系统中的重要概念之一，用于控制多个进程之间的执行顺序，以及对共享资源的访问。而C语言作为一种通用的编程语言，提供了多种进程同步机制来实现进程间的协作和互斥访问。本文将详细介绍C语言中的进程同步机制，包括互斥锁、条件变量和信号量。

1. 互斥锁

互斥锁（Mutex）是最简单且常用的进程同步机制之一。它允许只有一个进程对共享资源进行访问。通过使用互斥锁，可以确保在同一时刻只有一个进程可以访问共享资源，其他进程必须等待互斥锁释放才能再次访问。

#include 
#include 

#define NUM_THREADS 10

int shared_variable = 0;
pthread_mutex_t mutex;

void* thread_function(void* arg) {
    pthread_mutex_lock(&mutex);  // 加锁
    shared_variable++;  // 对共享资源进行操作
    printf("Thread %ld incremented the shared variable to %d\n",
           (long)arg, shared_variable);
    pthread_mutex_unlock(&mutex);  // 解锁
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    pthread_mutex_init(&mutex, NULL);
    
    for (long t = 0; t < NUM_THREADS; t++) {
        pthread_create(&threads[t], NULL, thread_function, (void*)t);
    }
    
    for (long t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }
    
    pthread_mutex_destroy(&mutex);
    return 0;
}

2. 条件变量

条件变量（Condition Variable）用于实现线程之间的通信和同步，它允许一个线程等待某个条件的发生，并在特定条件满足时通知等待的线程。常用的条件变量函数包括pthread_cond_init、pthread_cond_wait、pthread_cond_signal和pthread_cond_broadcast。

#include 
#include 

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_producer, cond_consumer;

void* producer(void* arg) {
    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);
        while (count >= BUFFER_SIZE) {
            pthread_cond_wait(&cond_producer, &mutex);
        }
        buffer[count++] = i;
        printf("Producer produced: %d\n", i);
        pthread_cond_signal(&cond_consumer);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

void* consumer(void* arg) {
    for (int i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);
        while (count == 0) {
            pthread_cond_wait(&cond_consumer, &mutex);
        }
        int data = buffer[--count];
        printf("Consumer consumed: %d\n", data);
        pthread_cond_signal(&cond_producer);
        pthread_mutex_unlock(&mutex);
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t producer_thread, consumer_thread;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_producer, NULL);
    pthread_cond_init(&cond_consumer, NULL);
    
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_producer);
    pthread_cond_destroy(&cond_consumer);
    
    return 0;
}

3. 信号量

信号量（Semaphore）是一种用于保护共享资源的进程同步机制。它可以用来控制同时访问共享资源的进程数量或者用于线程之间的同步。信号量提供了两个基本操作：P（等待）和V（发信号）。当一个进程访问共享资源时，首先执行P操作，如果信号量的值大于0，则进程可以访问资源；否则，进程将被阻塞。当进程完成对共享资源的访问后，执行V操作，将信号量的值增加1。

#include 
#include 
#include 

#define NUM_THREADS 10

int shared_variable = 0;
sem_t semaphore;

void* thread_function(void* arg) {
    sem_wait(&semaphore);
    shared_variable++;
    printf("Thread %ld incremented the shared variable to %d\n",
           (long)arg, shared_variable);
    sem_post(&semaphore);
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    sem_init(&semaphore, 0, 1);
    
    for (long t = 0; t < NUM_THREADS; t++) {
        pthread_create(&threads[t], NULL, thread_function, (void*)t);
    }
    
    for (long t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }
    
    sem_destroy(&semaphore);
    return 0;
}

总结

本文详细介绍了C语言中的进程同步机制，包括互斥锁、条件变量和信号量。互斥锁可用于确保同一时刻只有一个进程对共享资源进行访问，条件变量用于实现线程之间的通信和同步，而信号量可以用于控制共享资源的访问数量。通过合理地使用这些进程同步机制，可以保证多个进程协调工作，避免竞争条件和数据不一致等问题。