详解C语言进程同步机制

本文主要介绍C语言中的进程同步机制，包括互斥锁、条件变量和信号量的使用方法和注意事项。

互斥锁

互斥锁是一种用于保护共享资源的机制，只允许一个线程或进程进行操作，其他线程或进程需要等待锁的释放才能进行操作。

互斥锁的定义

互斥锁的定义如下：

#include <pthread.h>
pthread_mutex_t mutex;

互斥锁的初始化

在使用互斥锁前需要进行初始化，可以使用如下函数进行初始化：

pthread_mutex_init(&mutex, NULL);

互斥锁的加锁和解锁

在需要保护共享资源的代码块中，可以使用如下函数进行加锁和解锁：

pthread_mutex_lock(&mutex);

// 对共享资源的操作

pthread_mutex_unlock(&mutex);

互斥锁的销毁

在不需要使用互斥锁时需要进行销毁，可以使用如下函数进行销毁：

pthread_mutex_destroy(&mutex);

互斥锁的示例

下面是一个使用互斥锁保护共享变量的示例：

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

pthread_mutex_t mutex;
int shared_variable = 0;

void *thread_function(void *arg) {
    pthread_mutex_lock(&mutex);

    shared_variable++;
    printf("thread_function: shared_variable=%d\n", shared_variable);

    pthread_mutex_unlock(&mutex);
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, &thread_function, NULL);
    }

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

    pthread_mutex_destroy(&mutex);
    return 0;
}

在上述示例中，多个线程同时对共享变量进行操作，但是由于互斥锁的保护，只有一个线程能够对变量进行修改。运行上述代码，会发现每次线程对变量的操作都是按顺序进行的，没有出现错误。

条件变量

条件变量是一种用于线程之间通信的机制，可以通过条件变量实现线程间的协调和通知。

条件变量的定义

条件变量的定义如下：

#include <pthread.h>
pthread_cond_t cond;

条件变量的初始化

在使用条件变量前需要进行初始化，可以使用如下函数进行初始化：

pthread_cond_init(&cond, NULL);

条件变量的等待和唤醒

在需要等待或唤醒线程时，可以使用如下函数：

pthread_cond_wait(&cond, &mutex); // 等待条件变量的信号，并且会解锁mutex。 

pthread_cond_signal(&cond); // 唤醒一个等待条件变量的线程。

pthread_cond_broadcast(&cond); // 唤醒所有等待条件变量的线程。

条件变量的销毁

在不需要使用条件变量时需要进行销毁，可以使用如下函数进行销毁：

pthread_cond_destroy(&cond);

条件变量的示例

下面是一个使用条件变量实现线程等待和唤醒的示例：

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

pthread_mutex_t mutex;
pthread_cond_t cond;
int ready = 0;

void *thread_function(void *arg) {
    pthread_mutex_lock(&mutex);

    while (ready == 0) {
        pthread_cond_wait(&cond, &mutex);
    }

    printf("thread_function: ready=%d\n", ready);
    pthread_mutex_unlock(&mutex);
}

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

    pthread_create(&thread, NULL, &thread_function, NULL);

    // 模拟一些耗时操作

    printf("main: ready=1\n");
    ready = 1;

    pthread_cond_signal(&cond);

    pthread_join(thread, NULL);

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

在上述示例中，主线程先创建了一个线程，然后模拟了一些耗时操作后将共享变量ready设置为1，并通过条件变量唤醒等待线程。等待线程收到了信号后再次检查ready变量的值，发现已经被修改为1，于是退出等待状态。

信号量

信号量是一种用于控制对共享资源访问的机制，可以通过信号量限制同时访问共享资源的进程或线程的数量。

信号量的定义

信号量的定义如下：

#include <semaphore.h>
sem_t semaphore;

信号量的初始化

在使用信号量前需要进行初始化，可以使用如下函数进行初始化：

sem_init(&semaphore, 0, 1);

其中，第三个参数表示信号量的初值，一般设置为1或者0。

信号量的P操作和V操作

在需要访问共享变量时，可以使用如下函数进行P操作和V操作：

sem_wait(&semaphore); // P操作

// 对共享资源的操作

sem_post(&semaphore); // V操作

在上述代码中，sem_wait函数会对信号量进行减1操作，如果信号量的值为0，则会等待其他进程或线程进行V操作。sem_post函数会对信号量进行加1操作。

信号量的销毁

在不需要使用信号量时需要进行销毁，可以使用如下函数进行销毁：

sem_destroy(&semaphore);

信号量的示例

下面是一个使用信号量实现限制对共享变量的并发访问的示例：

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

sem_t semaphore;
int shared_variable = 0;

void *thread_function(void *arg) {
    sem_wait(&semaphore);

    shared_variable++;
    printf("thread_function: shared_variable=%d\n", shared_variable);

    sem_post(&semaphore);
}

int main() {
    pthread_t threads[10];
    sem_init(&semaphore, 0, 1);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, &thread_function, NULL);
    }

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

    sem_destroy(&semaphore);
    return 0;
}

在上述示例中，多个线程同时对共享变量进行操作，但是由于信号量的保护，只允许一个线程进行操作。运行上述代码，会发现每次线程对变量的操作都是按顺序进行的，没有出现错误。