Linux C语言互斥锁的嵌套使用
2023-03-062.9k 阅读
一、互斥锁基础概念
1.1 什么是互斥锁
在Linux C语言编程中，互斥锁（Mutex，即Mutual Exclusion的缩写）是一种基本的同步机制，用于保护共享资源，确保在同一时刻只有一个线程能够访问该资源。互斥锁就像是一把钥匙，线程在访问共享资源前必须先获取这把钥匙（锁），访问结束后再将钥匙归还（解锁）。这样可以避免多个线程同时访问共享资源导致的数据不一致或竞态条件等问题。
1.2 互斥锁的作用
- 防止竞态条件：当多个线程对共享资源进行读写操作时，如果没有同步机制，不同线程的操作顺序可能是不确定的，从而导致结果的不确定性。例如，一个线程正在读取共享变量的值，另一个线程同时对该变量进行修改，就会出现竞态条件。互斥锁通过保证同一时间只有一个线程能访问共享资源，有效避免了这种情况。
- 数据一致性：在多线程环境下，共享数据可能会被多个线程同时修改。互斥锁能够确保在对共享数据进行修改时，其他线程无法干扰，从而保证数据的一致性。例如，在一个银行转账的程序中，涉及到两个账户余额的修改，如果没有互斥锁保护，可能会出现一个账户余额减少了，而另一个账户余额没有相应增加的情况。
1.3 互斥锁的类型
在Linux下，互斥锁类型定义在<pthread.h>头文件中，通常使用pthread_mutex_t类型来表示互斥锁。它有几种不同的属性，可以通过pthread_mutexattr_t类型来设置。例如，默认的互斥锁是普通类型，还有递归类型、错误检查类型等。
- 普通互斥锁：这是最常见的类型。如果一个线程已经持有了普通互斥锁，其他线程试图再次获取该锁时会被阻塞，直到持有锁的线程释放锁。
- 递归互斥锁：递归互斥锁允许同一个线程多次获取该锁而不会造成死锁。每次获取锁时，锁的引用计数会增加，每次释放锁时，引用计数会减少，当引用计数为0时，锁才真正被释放。例如，在一个递归函数中，如果需要使用互斥锁保护共享资源，使用递归互斥锁就可以避免因递归调用自身而导致死锁的问题。
- 错误检查互斥锁：当一个线程试图再次获取它已经持有的错误检查互斥锁时，会返回一个错误，而不是像普通互斥锁那样阻塞。这种类型的互斥锁有助于调试多线程程序中的死锁问题。
二、Linux下C语言互斥锁的基本操作
2.1 互斥锁的初始化
在使用互斥锁之前，需要先对其进行初始化。有两种初始化互斥锁的方法：静态初始化和动态初始化。
- 静态初始化：
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
这种方式适用于互斥锁在程序运行期间不需要改变其属性的情况。PTHREAD_MUTEX_INITIALIZER是一个宏，它为互斥锁提供了一个默认的初始值。
2. 动态初始化：
#include <pthread.h>
pthread_mutex_t mutex;
int ret = pthread_mutex_init(&mutex, NULL);
if (ret != 0) {
perror("pthread_mutex_init");
// 处理错误
}
在动态初始化中，pthread_mutex_init函数的第一个参数是指向互斥锁变量的指针，第二个参数是指向互斥锁属性对象的指针。如果不需要设置特殊属性，可以将第二个参数设置为NULL，这样会使用默认属性初始化互斥锁。如果初始化成功，函数返回0；否则返回一个非零的错误码，可以通过perror函数打印错误信息。
2.2 互斥锁的获取
获取互斥锁意味着尝试获取访问共享资源的权限。在C语言中，使用pthread_mutex_lock函数来获取互斥锁。
#include <pthread.h>
pthread_mutex_t mutex;
// 假设已经初始化了互斥锁
int ret = pthread_mutex_lock(&mutex);
if (ret != 0) {
perror("pthread_mutex_lock");
// 处理错误
}
// 临界区，访问共享资源
// ......
当一个线程调用pthread_mutex_lock时，如果互斥锁当前未被锁定，该线程将立即获取锁并继续执行后续代码。如果互斥锁已经被其他线程锁定，调用线程将被阻塞，直到互斥锁被释放。
2.3 互斥锁的释放
在访问完共享资源后，需要释放互斥锁，以便其他线程能够获取锁并访问共享资源。使用pthread_mutex_unlock函数来释放互斥锁。
#include <pthread.h>
pthread_mutex_t mutex;
// 假设已经获取了互斥锁
// 临界区，访问共享资源
// ......
int ret = pthread_mutex_unlock(&mutex);
if (ret != 0) {
perror("pthread_mutex_unlock");
// 处理错误
}
释放互斥锁时，如果有其他线程正在等待获取该锁，系统会从等待队列中选择一个线程并将锁授予它。如果pthread_mutex_unlock函数执行成功，返回0；否则返回一个非零的错误码。
2.4 互斥锁的销毁
当互斥锁不再需要使用时，应该将其销毁以释放相关资源。使用pthread_mutex_destroy函数来销毁互斥锁。
#include <pthread.h>
pthread_mutex_t mutex;
// 假设已经使用完互斥锁
int ret = pthread_mutex_destroy(&mutex);
if (ret != 0) {
perror("pthread_mutex_destroy");
// 处理错误
}
销毁互斥锁时，必须确保没有任何线程持有该锁，否则会导致未定义行为。如果互斥锁是动态初始化的，在程序结束时应该进行销毁操作；如果是静态初始化的，通常不需要手动销毁，因为程序结束时系统会自动回收相关资源。
三、互斥锁的嵌套使用场景
3.1 复杂数据结构的保护
在实际编程中，经常会遇到复杂的数据结构，例如嵌套的链表、树等。这些数据结构可能包含多个层次的共享资源，并且在对其进行操作时，可能需要在不同的函数或方法中进行，而这些函数或方法可能会嵌套调用。为了确保在对这些复杂数据结构进行操作时的线程安全性，就需要使用互斥锁的嵌套。
例如，假设有一个包含多个子链表的链表结构，每个子链表又包含多个节点。在对整个链表进行遍历和修改操作时，可能需要先获取链表级别的互斥锁，然后在遍历子链表时获取子链表级别的互斥锁。这样可以保证在操作整个链表结构时，不同线程不会相互干扰，同时在操作子链表时，也能保证线程安全。
3.2 层次化资源访问
在一些系统中，资源是按照层次结构组织的。例如，在一个文件系统模拟程序中，可能有目录和文件的层次结构。对文件的操作可能依赖于对其父目录的操作，并且在多线程环境下，需要确保对目录和文件的操作都是线程安全的。这时可以使用互斥锁的嵌套，先获取目录级别的互斥锁，再获取文件级别的互斥锁。这样可以保证在对文件进行操作时，其父目录不会被其他线程同时修改，从而避免数据不一致的问题。
3.3 递归函数与共享资源
当递归函数需要访问共享资源时，也可能会用到互斥锁的嵌套。由于递归函数会不断调用自身，每次调用都可能需要获取互斥锁来保护共享资源。如果使用普通互斥锁，会导致死锁，因为同一个线程不能多次获取普通互斥锁。而使用递归互斥锁，并进行适当的嵌套使用，可以解决这个问题。例如，在一个递归计算目录下所有文件大小的函数中，可能需要获取目录级别的互斥锁，并且在递归进入子目录时，再次获取子目录级别的互斥锁（如果有必要），以确保对目录和文件相关操作的线程安全性。
四、互斥锁嵌套使用的注意事项
4.1 死锁问题
- 死锁原因：在互斥锁嵌套使用时，最容易出现的问题就是死锁。死锁通常发生在两个或多个线程相互等待对方释放锁的情况下。例如，线程A获取了互斥锁1，然后试图获取互斥锁2；同时线程B获取了互斥锁2，然后试图获取互斥锁1。这样两个线程就会永远阻塞，形成死锁。在嵌套使用互斥锁时，如果获取锁的顺序不一致，就很容易导致死锁。比如，在一个函数中先获取锁A再获取锁B，而在另一个函数中先获取锁B再获取锁A，当两个线程分别调用这两个函数时，就可能出现死锁。
- 避免死锁的方法：
- 固定锁获取顺序：为所有的互斥锁定义一个获取顺序，在整个程序中，所有线程都按照这个顺序获取锁。例如，在处理复杂数据结构时，可以按照从外层到内层的顺序获取互斥锁。如果有链表级别的互斥锁和子链表级别的互斥锁，所有线程都先获取链表级别的互斥锁，再获取子链表级别的互斥锁。
- 使用超时机制：可以使用
pthread_mutex_timedlock函数，它允许线程在尝试获取锁时设置一个超时时间。如果在指定时间内未能获取锁，函数会返回一个错误，线程可以根据这个错误进行相应处理，而不是一直阻塞等待，从而避免死锁。例如：
#include <pthread.h>
#include <time.h>
pthread_mutex_t mutex1, mutex2;
struct timespec timeout;
clock_gettime(CLOCK_REALTIME, &timeout);
timeout.tv_sec += 1; // 设置1秒超时
int ret = pthread_mutex_timedlock(&mutex1, &timeout);
if (ret == 0) {
// 获取锁成功
ret = pthread_mutex_timedlock(&mutex2, &timeout);
if (ret == 0) {
// 获取第二个锁成功
// 临界区
pthread_mutex_unlock(&mutex2);
}
pthread_mutex_unlock(&mutex1);
} else if (ret == ETIMEDOUT) {
// 超时处理
}
4.2 性能问题
- 性能影响：虽然互斥锁可以保证线程安全，但过多地使用互斥锁，尤其是嵌套使用，会对程序性能产生一定影响。每次获取和释放互斥锁都需要一定的系统开销，包括上下文切换等操作。当互斥锁嵌套层数过多时，这种开销会累积，导致程序运行速度变慢。此外，如果临界区代码执行时间较长，其他线程等待锁的时间也会相应增加，进一步降低了程序的并发性能。
- 优化方法：
- 减小临界区：尽量将不需要保护的代码移出临界区，只在真正需要保护共享资源的代码段使用互斥锁。例如，在对链表进行遍历操作时，如果只是读取链表节点的数据，而不修改链表结构，可以在读取数据前获取互斥锁，读取完成后立即释放锁，而不是在整个遍历过程中一直持有锁。
- 使用粒度更细的锁：对于复杂数据结构，可以根据实际情况使用多个粒度更细的互斥锁，而不是一个大的互斥锁保护整个数据结构。例如，对于包含多个子链表的链表结构，可以为每个子链表单独设置一个互斥锁，而不是使用一个链表级别的互斥锁保护整个链表。这样，不同线程可以同时访问不同的子链表，提高并发性能。
4.3 代码复杂度
- 复杂度增加：互斥锁的嵌套使用会使代码复杂度显著增加。代码中不仅需要处理多个互斥锁的获取和释放，还需要考虑锁的嵌套顺序、死锁避免等问题。在调试过程中，也会因为多个锁的存在而增加难度。例如，当出现死锁时，需要分析多个线程获取锁的顺序和时机，找出死锁的原因。而且，嵌套的互斥锁使得代码逻辑更加复杂，可读性降低，增加了维护和扩展代码的难度。
- 管理方法：
- 封装和抽象：可以将互斥锁的操作封装成函数或类方法，隐藏互斥锁的具体实现细节，使上层代码只需要调用相应的接口来保护共享资源。例如，对于一个链表数据结构，可以将获取和释放链表互斥锁的操作封装在链表的操作函数中，如
list_insert、list_delete等函数，这样上层代码在调用这些函数时，不需要关心互斥锁的具体操作，只需要知道这些函数是线程安全的。 - 详细注释：在代码中添加详细的注释，说明每个互斥锁的作用、获取和释放的时机、锁的嵌套顺序等。这样不仅有助于自己在调试和维护代码时理解逻辑，也方便其他开发人员阅读和修改代码。例如，在获取互斥锁的代码行上方，可以注释说明获取该锁是为了保护哪个共享资源，以及在何处释放该锁。
- 封装和抽象：可以将互斥锁的操作封装成函数或类方法，隐藏互斥锁的具体实现细节，使上层代码只需要调用相应的接口来保护共享资源。例如，对于一个链表数据结构，可以将获取和释放链表互斥锁的操作封装在链表的操作函数中，如
五、互斥锁嵌套使用的代码示例
5.1 简单链表结构的线程安全操作
下面是一个简单链表结构的示例，展示如何使用互斥锁的嵌套来保证对链表操作的线程安全性。
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构
typedef struct Node {
int data;
struct Node* next;
} Node;
// 定义链表结构
typedef struct List {
Node* head;
pthread_mutex_t list_mutex;
} List;
// 初始化链表
void list_init(List* list) {
list->head = NULL;
pthread_mutex_init(&list->list_mutex, NULL);
}
// 创建新节点
Node* create_node(int data) {
Node* new_node = (Node*)malloc(sizeof(Node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// 向链表中插入节点
void list_insert(List* list, int data) {
pthread_mutex_lock(&list->list_mutex);
Node* new_node = create_node(data);
if (list->head == NULL) {
list->head = new_node;
} else {
Node* current = list->head;
while (current->next != NULL) {
current = current->next;
}
current->next = new_node;
}
pthread_mutex_unlock(&list->list_mutex);
}
// 从链表中删除节点
void list_delete(List* list, int data) {
pthread_mutex_lock(&list->list_mutex);
Node* current = list->head;
Node* prev = NULL;
while (current != NULL && current->data != data) {
prev = current;
current = current->next;
}
if (current != NULL) {
if (prev == NULL) {
list->head = current->next;
} else {
prev->next = current->next;
}
free(current);
}
pthread_mutex_unlock(&list->list_mutex);
}
// 打印链表
void list_print(List* list) {
pthread_mutex_lock(&list->list_mutex);
Node* current = list->head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
pthread_mutex_unlock(&list->list_mutex);
}
// 线程函数
void* thread_function(void* arg) {
List* list = (List*)arg;
for (int i = 0; i < 5; i++) {
list_insert(list, i);
}
list_print(list);
for (int i = 0; i < 3; i++) {
list_delete(list, i);
}
list_print(list);
return NULL;
}
int main() {
List list;
list_init(&list);
pthread_t thread1, thread2;
pthread_create(&thread1, NULL, thread_function, &list);
pthread_create(&thread2, NULL, thread_function, &list);
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
pthread_mutex_destroy(&list.list_mutex);
return 0;
}
在这个示例中，List结构体包含一个链表头指针和一个互斥锁list_mutex。list_insert、list_delete和list_print函数在操作链表时，都会先获取list_mutex锁，操作完成后再释放锁，从而保证了对链表操作的线程安全性。
5.2 复杂嵌套数据结构的线程安全操作
下面是一个更复杂的示例，展示对嵌套数据结构（包含多个子链表的链表）的线程安全操作。
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
// 定义子链表节点结构
typedef struct SubNode {
int data;
struct SubNode* next;
} SubNode;
// 定义子链表结构
typedef struct SubList {
SubNode* head;
pthread_mutex_t sublist_mutex;
} SubList;
// 定义主链表节点结构
typedef struct MainNode {
SubList* sublist;
struct MainNode* next;
} MainNode;
// 定义主链表结构
typedef struct MainList {
MainNode* head;
pthread_mutex_t mainlist_mutex;
} MainList;
// 初始化子链表
void sublist_init(SubList* sublist) {
sublist->head = NULL;
pthread_mutex_init(&sublist->sublist_mutex, NULL);
}
// 创建子链表新节点
SubNode* create_subnode(int data) {
SubNode* new_subnode = (SubNode*)malloc(sizeof(SubNode));
new_subnode->data = data;
new_subnode->next = NULL;
return new_subnode;
}
// 向子链表中插入节点
void sublist_insert(SubList* sublist, int data) {
pthread_mutex_lock(&sublist->sublist_mutex);
SubNode* new_subnode = create_subnode(data);
if (sublist->head == NULL) {
sublist->head = new_subnode;
} else {
SubNode* current = sublist->head;
while (current->next != NULL) {
current = current->next;
}
current->next = new_subnode;
}
pthread_mutex_unlock(&sublist->sublist_mutex);
}
// 从子链表中删除节点
void sublist_delete(SubList* sublist, int data) {
pthread_mutex_lock(&sublist->sublist_mutex);
SubNode* current = sublist->head;
SubNode* prev = NULL;
while (current != NULL && current->data != data) {
prev = current;
current = current->next;
}
if (current != NULL) {
if (prev == NULL) {
sublist->head = current->next;
} else {
prev->next = current->next;
}
free(current);
}
pthread_mutex_unlock(&sublist->sublist_mutex);
}
// 打印子链表
void sublist_print(SubList* sublist) {
pthread_mutex_lock(&sublist->sublist_mutex);
SubNode* current = sublist->head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
pthread_mutex_unlock(&sublist->sublist_mutex);
}
// 初始化主链表
void mainlist_init(MainList* mainlist) {
mainlist->head = NULL;
pthread_mutex_init(&mainlist->mainlist_mutex, NULL);
}
// 创建主链表新节点
MainNode* create_mainnode() {
MainNode* new_mainnode = (MainNode*)malloc(sizeof(MainNode));
new_mainnode->sublist = (SubList*)malloc(sizeof(SubList));
sublist_init(new_mainnode->sublist);
new_mainnode->next = NULL;
return new_mainnode;
}
// 向主链表中插入子链表节点
void mainlist_insert(MainList* mainlist) {
pthread_mutex_lock(&mainlist->mainlist_mutex);
MainNode* new_mainnode = create_mainnode();
if (mainlist->head == NULL) {
mainlist->head = new_mainnode;
} else {
MainNode* current = mainlist->head;
while (current->next != NULL) {
current = current->next;
}
current->next = new_mainnode;
}
pthread_mutex_unlock(&mainlist->mainlist_mutex);
}
// 从主链表中删除子链表节点
void mainlist_delete(MainList* mainlist) {
pthread_mutex_lock(&mainlist->mainlist_mutex);
MainNode* current = mainlist->head;
MainNode* prev = NULL;
if (current != NULL) {
if (prev == NULL) {
mainlist->head = current->next;
} else {
prev->next = current->next;
}
pthread_mutex_destroy(¤t->sublist->sublist_mutex);
free(current->sublist);
free(current);
}
pthread_mutex_unlock(&mainlist->mainlist_mutex);
}
// 打印主链表及其子链表
void mainlist_print(MainList* mainlist) {
pthread_mutex_lock(&mainlist->mainlist_mutex);
MainNode* current = mainlist->head;
while (current != NULL) {
printf("Sub - List: ");
sublist_print(current->sublist);
current = current->next;
}
pthread_mutex_unlock(&mainlist->mainlist_mutex);
}
// 线程函数
void* thread_function2(void* arg) {
MainList* mainlist = (MainList*)arg;
mainlist_insert(mainlist);
mainlist_print(mainlist);
mainlist_delete(mainlist);
mainlist_print(mainlist);
return NULL;
}
int main() {
MainList mainlist;
mainlist_init(&mainlist);
pthread_t thread1, thread2;
pthread_create(&thread1, NULL, thread_function2, &mainlist);
pthread_create(&thread2, NULL, thread_function2, &mainlist);
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
pthread_mutex_destroy(&mainlist.mainlist_mutex);
return 0;
}
在这个示例中，MainList结构体包含一个主链表头指针和一个主链表互斥锁mainlist_mutex，每个主链表节点又包含一个子链表，子链表有自己的互斥锁sublist_mutex。在对主链表和子链表进行操作时，先获取主链表互斥锁，再根据需要获取子链表互斥锁，从而保证了对嵌套数据结构操作的线程安全性。
通过以上示例和讲解，希望能帮助你深入理解Linux C语言中互斥锁的嵌套使用，在实际多线程编程中更好地运用这一技术来保证程序的正确性和性能。