互斥量mutex的简单使用(实例讲解)

什么是互斥量mutex

互斥量是一种用于保护共享资源的锁，它可以防止多个线程同时访问共享资源，从而保证线程安全。

如何使用互斥量

在使用互斥量之前，我们需要了解一些基本操作。

初始化互斥量

初始化互斥量可以使用pthread_mutex_init函数，该函数有两个参数，第一个参数是互斥量的指针，第二个参数是一个指向pthread_mutexattr_t结构体的指针，通常使用NULL表示使用默认属性。

下面是一个示例代码：

#include <pthread.h>

pthread_mutex_t mutex;

int main()
{
    pthread_mutex_init(&mutex, NULL);
    // 其他操作
    return 0;
}

加锁

加锁可以使用pthread_mutex_lock函数，该函数会阻塞线程，直到获取到互斥量为止。

下面是一个示例代码：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    // 创建线程
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    // 主线程访问共享资源
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    // 等待线程结束
    pthread_join(thread, NULL);
    return 0;
}

解锁

解锁可以使用pthread_mutex_unlock函数，该函数会释放互斥量。

下面是一个示例代码：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    // 创建线程
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    // 主线程访问共享资源
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    // 等待线程结束
    pthread_join(thread, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

销毁互斥量

销毁互斥量可以使用pthread_mutex_destroy函数，该函数会销毁互斥量。

下面是一个示例代码：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    // 创建线程
    pthread_t thread;
    pthread_create(&thread, NULL, thread_func, NULL);
    // 主线程访问共享资源
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
    // 等待线程结束
    pthread_join(thread, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

示例说明

示例一

下面是一个简单的示例，该示例中，我们定义了一个全局变量counter，然后创建两个线程，每个线程循环1000次，每次都将counter加1，由于没有使用互斥量，所以最后结果可能不符合预期。

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

int counter = 0;

void* thread_func(void* arg)
{
    int i;
    for(i=0; i<1000; i++)
    {
        counter++;
    }
    return NULL;
}

int main()
{
    pthread_t threads[2];
    int i;
    for(i=0; i<2; i++)
    {
        pthread_create(&threads[i], NULL, thread_func, NULL);
    }
    for(i=0; i<2; i++)
    {
        pthread_join(threads[i], NULL);
    }
    printf("counter=%d\n", counter);
    return 0;
}

示例二

下面是一个修正示例，该示例中，我们使用了互斥量来保护全局变量counter，从而保证线程安全。

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

pthread_mutex_t mutex;

int counter = 0;

void* thread_func(void* arg)
{
    int i;
    for(i=0; i<1000; i++)
    {
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    pthread_t threads[2];
    int i;
    for(i=0; i<2; i++)
    {
        pthread_create(&threads[i], NULL, thread_func, NULL);
    }
    for(i=0; i<2; i++)
    {
        pthread_join(threads[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    printf("counter=%d\n", counter);
    return 0;
}

在示例二中，我们定义了一个全局变量mutex，然后在thread_func函数中先使用pthread_mutex_lock函数加锁，然后访问全局变量counter，最后使用pthread_mutex_unlock函数解锁，这样就能保证线程安全了。此外，在main函数中，我们使用pthread_mutex_init函数初始化互斥量，使用pthread_mutex_destroy函数销毁互斥量。