深入解析互斥锁：从基本概念到操作系统应用

创作时间:

2025-01-21 23:09:11

作者:

@小白创作中心

深入解析互斥锁：从基本概念到操作系统应用

在多线程和多进程的并发环境中，互斥锁（Mutex）作为操作系统中重要的同步机制，确保了共享资源的一致性和可靠性。本文将深入探讨互斥锁的基本概念、工作原理，并通过具体实例展示其在操作系统中的应用。

互斥锁的基本概念

互斥锁（Mutex，Mutual Exclusion Object的简称）是一种常用的同步机制，用于控制多个线程或进程对共享资源的独占访问。在多线程或多进程编程中，当多个执行单位（如线程）需要访问同一份共享数据时，如果没有适当的同步措施，可能会导致竞态条件（race condition），从而引起程序行为的不确定性。

互斥锁的主要作用是确保同一时刻只有一个线程可以访问特定的共享资源。当一个线程对互斥锁加锁后，任何其他试图对该锁加锁的线程都将被阻塞，直到原始持有锁的线程释放锁。

互斥锁与信号量（Semaphore）虽然都用于进程间的同步与互斥，但存在本质区别：

互斥锁主要用于实现互斥访问，而信号量可以控制多个资源的访问
互斥锁具有严格的所有权，只能由加锁的线程解锁
互斥锁适用于保护临界区，确保资源的独占访问

互斥锁在Linux中的应用

在Linux系统中，互斥锁主要通过POSIX线程库（pthread）实现。以下是一些关键的互斥锁操作函数：

pthread_mutex_init：初始化互斥锁
pthread_mutex_destroy：销毁互斥锁
pthread_mutex_lock：加锁
pthread_mutex_trylock：尝试加锁，若锁已被占用则立即返回
pthread_mutex_unlock：解锁

下面是一个具体的代码示例，展示了两个线程如何使用互斥锁来安全地操作一个全局变量：

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

// 定义一个全局变量
int global_counter = 0;

// 创建一个互斥锁
pthread_mutex_t counter_lock;

// 函数用于修改全局变量
void increment_counter() {
    int ret = -1;

    while(ret != 0)
    {
    ret = pthread_mutex_trylock(&counter_lock);
    if(0 == ret)
    {
        global_counter++;                  // 修改全局变量
        pthread_mutex_unlock(&counter_lock); // 解锁
    }else if(ret == EBUSY)
    {
        printf("EBUSY\n");
    }else
    {
        printf("pthread_mutex_trylock error ret = %d\n", ret);
    }
    }
}

// 线程函数
void* thread_function(void* arg) {
    int i;
    for (i = 0; i < 10; i++) {
        printf("thread_function enter id = %d, i = %d, global_counter = %d\n", *((int *)arg),i, global_counter);
        increment_counter();
        usleep(1); // 防止第一个线程执行完，第二个线程才执行
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    int i = 1;
    int j = 2;

    // 初始化互斥锁
    pthread_mutex_init(&counter_lock, NULL);

    // 创建两个线程
    pthread_create(&thread1, NULL, thread_function, &i);
    pthread_create(&thread2, NULL, thread_function, &j);

    // 等待两个线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

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

    // 输出最终的全局变量值
    printf("Final value of the counter is %d\n", global_counter);

    return 0;
}

在这个例子中，两个线程通过互斥锁来确保对全局变量global_counter的独占访问，避免了数据竞争和不一致的问题。

互斥锁在其他操作系统中的实现

以鸿蒙轻内核为例，其互斥锁的实现细节展示了操作系统层面的同步机制设计思路。

鸿蒙轻内核的互斥锁结构体定义如下：

typedef struct {
    UINT8 muxStat;       /**< 互斥锁状态：OS_MUX_UNUSED, OS_MUX_USED */
    UINT16 muxCount;     /**< 锁被持有的次数 */
    UINT32 muxID;        /**< 互斥锁Id */
    LOS_DL_LIST muxList; /**< 互斥锁双向链表 */
    LosTaskCB *owner;    /**< 当前持有锁的任务 */
    UINT16 priority;     /**< 当前持有锁的任务的优先级，为避免优先级翻转，可能会更改任务的优先级，此时有备份的作用 */
} LosMuxCB;

互斥锁的初始化过程包括：