Linux进程同步：互斥锁的使用方法 - 问答

在Linux中，互斥锁（mutex）是一种用于实现进程间或线程间同步的机制，确保多个进程或线程不会同时访问共享资源。以下是使用互斥锁的基本步骤：

1. 包含头文件

首先，需要包含相关的头文件：

#include <pthread.h>

2. 定义互斥锁

定义一个互斥锁变量：

pthread_mutex_t mutex;

3. 初始化互斥锁

在使用互斥锁之前，必须对其进行初始化。可以在程序开始时使用pthread_mutex_init函数进行初始化：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

mutex是指向互斥锁变量的指针。
attr是指向互斥锁属性的指针，通常设置为NULL以使用默认属性。

示例：

int ret = pthread_mutex_init(&mutex, NULL);
if (ret != 0) {
    // 处理错误
}

4. 加锁

在访问共享资源之前，使用pthread_mutex_lock函数对互斥锁进行加锁：

int pthread_mutex_lock(pthread_mutex_t *mutex);

mutex是指向互斥锁变量的指针。

示例：

ret = pthread_mutex_lock(&mutex);
if (ret != 0) {
    // 处理错误
}

5. 解锁

在访问完共享资源之后，使用pthread_mutex_unlock函数对互斥锁进行解锁：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

mutex是指向互斥锁变量的指针。

示例：

ret = pthread_mutex_unlock(&mutex);
if (ret != 0) {
    // 处理错误
}

6. 销毁互斥锁

在程序结束时，使用pthread_mutex_destroy函数销毁互斥锁：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

mutex是指向互斥锁变量的指针。

示例：

ret = pthread_mutex_destroy(&mutex);
if (ret != 0) {
    // 处理错误
}

完整示例

以下是一个简单的示例，展示了如何使用互斥锁来保护共享资源：

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

pthread_mutex_t mutex;
int shared_resource = 0;

void* thread_func(void* arg) {
    int thread_id = *(int*)arg;

    // 加锁
    pthread_mutex_lock(&mutex);

    // 访问共享资源
    shared_resource++;
    printf("Thread %d: shared_resource = %d\n", thread_id, shared_resource);

    // 解锁
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main() {
    pthread_t threads[2];
    int thread_ids[2] = {1, 2};

    // 初始化互斥锁
    if (pthread_mutex_init(&mutex, NULL) != 0) {
        perror("pthread_mutex_init");
        return 1;
    }

    // 创建线程
    for (int i = 0; i < 2; i++) {
        if (pthread_create(&threads[i], NULL, thread_func, &thread_ids[i]) != 0) {
            perror("pthread_create");
            return 1;
        }
    }

    // 等待线程结束
    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }

    // 销毁互斥锁
    pthread_mutex_destroy(&mutex);

    return 0;
}

在这个示例中，两个线程并发地访问共享资源shared_resource，通过互斥锁确保每次只有一个线程可以访问该资源。

0 赞

0 踩