Linux线程同步之互斥量加锁解锁

在 Linux 系统中，多个线程同时访问共享资源可能会导致数据竞争问题，为了避免这种情况，我们需要使用线程同步机制。其中，互斥量（mutex）是一种常见的线程同步工具，用于保护共享资源的访问。

互斥量的使用需要加锁和解锁操作。当一个线程需要访问共享资源时，它会先尝试获得互斥量的锁，如果该锁已经被其他线程持有，则该线程会进入阻塞状态等待锁被释放。当该线程成功获得互斥量的锁后，它就可以访问共享资源了。当访问结束后，该线程需要释放互斥量的锁，让其他线程继续访问共享资源。

下面是互斥量的加锁和解锁代码示例：

#include <pthread.h>

// 定义互斥量
pthread_mutex_t mutex;

// 初始化互斥量
pthread_mutex_init(&mutex, NULL);

// 加锁
pthread_mutex_lock(&mutex);

// 访问共享资源

// 解锁
pthread_mutex_unlock(&mutex);

需要注意的是，使用互斥量进行线程同步时，需要保证所有线程都使用同一个互斥量来访问共享资源。此外，在加锁和解锁操作中，也需要注意锁的粒度和持有时间，以避免出现死锁等问题。

相关问题

利用PSAP在 Linux系统上,通过多线程和互斥量机制实现哲学家进餐问题。

哲学家进餐问题是经典的同步问题之一，它描述了5个哲学家共用一张桌子和5个餐叉的情景，每个哲学家必须交替地思考和进餐，但只有同时拿到左右两个餐叉才能进餐。如果每个哲学家都拿起自己左边的餐叉，则会造成死锁。

在 Linux 系统上，可以使用 pthread 库实现多线程和互斥量机制来解决这个问题。以下是一个利用 PSAP 在 Linux 系统上实现哲学家进餐问题的示例代码：

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

#define N 5    // 哲学家数量
#define LEFT (i+N-1)%N  // 左边哲学家编号
#define RIGHT (i+1)%N   // 右边哲学家编号
#define THINKING 0      // 思考状态
#define HUNGRY 1        // 饥饿状态
#define EATING 2        // 就餐状态

int state[N];           // 哲学家状态数组
pthread_mutex_t mutex;  // 互斥量数组
pthread_cond_t cond[N]; // 条件变量数组

void *philosopher(void *arg) {
    int i = *(int *)arg;
    while (1) {
        printf("Philosopher %d is thinking...\n", i);
        sleep(rand() % 5 + 1);  // 模拟思考过程

        pthread_mutex_lock(&mutex);  // 加锁
        state[i] = HUNGRY;            // 改变哲学家状态
        printf("Philosopher %d is hungry...\n", i);
        while (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {
            pthread_cond_wait(&cond[i], &mutex);  // 等待条件变量
        }
        state[i] = EATING;  // 改变哲学家状态
        printf("Philosopher %d is eating...\n", i);
        pthread_mutex_unlock(&mutex);  // 解锁

        sleep(rand() % 5 + 1);  // 模拟就餐过程

        pthread_mutex_lock(&mutex);  // 加锁
        state[i] = THINKING;  // 改变哲学家状态
        printf("Philosopher %d is thinking...\n", i);
        pthread_cond_signal(&cond[LEFT]);   // 唤醒左边的哲学家
        pthread_cond_signal(&cond[RIGHT]);  // 唤醒右边的哲学家
        pthread_mutex_unlock(&mutex);      // 解锁
    }
}

int main() {
    int i;
    pthread_t tid[N];
    int index[N];
    for (i = 0; i < N; i++) {
        pthread_cond_init(&cond[i], NULL);
        state[i] = THINKING;
        index[i] = i;
    }
    pthread_mutex_init(&mutex, NULL);
    for (i = 0; i < N; i++) {
        pthread_create(&tid[i], NULL, philosopher, &index[i]);
    }
    for (i = 0; i < N; i++) {
        pthread_join(tid[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    for (i = 0; i < N; i++) {
        pthread_cond_destroy(&cond[i]);
    }
    return 0;
}

在上述代码中，state 数组表示每个哲学家的状态，mutex 是互斥量数组，cond 数组是条件变量数组。在 philosopher 函数中，每个哲学家的思考和进餐过程被封装在一个无限循环内，直到程序结束。在循环内部，哲学家首先进入思考状态，然后变为饥饿状态，等待条件变量的唤醒。当左右两边的哲学家都没有在进餐时，当前哲学家才能进餐。进餐过程中，哲学家首先改变自己的状态为就餐状态，然后模拟就餐过程，最后改变状态为思考状态，唤醒左右两边的哲学家。在主函数中，首先初始化互斥量和条件变量，然后创建多个线程，最后等待线程结束并销毁互斥量和条件变量。