C语言如何避免死锁

创作时间:

作者:

@小白创作中心

C语言如何避免死锁

引用

来源

https://docs.pingcode.com/baike/1167867

在多线程编程中，死锁是一个常见的问题，它会导致程序陷入无限等待的状态。本文将介绍在C语言中避免死锁的几种方法，包括谨慎使用锁机制、避免嵌套锁、使用超时机制、按序请求资源和使用死锁检测算法。通过这些方法，可以有效地避免死锁问题，提高程序的稳定性和可靠性。

谨慎使用锁机制

在多线程编程中，锁是常用的同步机制，用于保护共享资源。但过度或不当使用锁会导致死锁。为了避免死锁，开发者应考虑以下几点：

减少锁的使用：尽量减少锁的数量和使用频率，使用无锁数据结构和算法来替代。例如，无锁队列和无锁栈通过原子操作来保证线程安全，避免了死锁问题。
使用细粒度锁：将大锁拆分成多个小锁，以提高并发性和减少死锁的可能性。例如，在一个复杂的数据结构中，可以为每个子部分使用单独的锁，而不是为整个结构使用一个大锁。
审慎设计锁的持有时间：锁的持有时间应尽量短，以减少其他线程等待的时间。例如，在临界区内只执行必要的操作，避免长时间持有锁。

避免嵌套锁

嵌套锁是指在一个线程内持有一个锁的同时，又去请求另一个锁，这种情况容易导致死锁。为了避免嵌套锁，开发者应：

尽量避免嵌套锁：在设计程序时，尽量避免在一个锁持有期间再去请求另一个锁。例如，可以将需要同时访问的资源合并到一个锁中。
使用递归锁：递归锁允许同一个线程多次获取同一个锁，而不会导致死锁。在C语言中，可以使用pthread_mutex_t的PTHREAD_MUTEX_RECURSIVE属性来创建递归锁。
避免锁的循环依赖：确保线程获取锁的顺序一致，避免形成锁的循环依赖。例如，在多个线程中使用相同的锁获取顺序，避免A线程持有锁1请求锁2，而B线程持有锁2请求锁1。

使用超时机制

超时机制允许线程在请求锁时设置超时时间，如果在超时时间内未能获取锁，线程将放弃请求，从而避免死锁。可以通过以下方式实现超时机制：

使用条件变量：在C语言中，可以使用pthread_cond_t条件变量与互斥锁结合，实现超时等待。例如，线程在等待条件变量时可以设置超时时间，如果超时则放弃等待。
使用带超时的锁函数：在一些多线程库中，提供了带超时的锁函数，例如pthread_mutex_timedlock。线程在请求锁时可以设置超时时间，如果超时则返回错误码，表示获取锁失败。
自定义超时机制：如果使用的多线程库不支持带超时的锁函数，可以通过自定义超时机制实现。例如，使用循环尝试获取锁，并在每次尝试前检查当前时间是否超过设定的超时时间。

按序请求资源

按序请求资源是避免死锁的有效方法之一。通过规定线程获取资源的顺序，可以避免循环依赖，从而避免死锁。例如：

定义资源顺序：在程序设计阶段，定义好所有共享资源的获取顺序。例如，如果有资源A和资源B，规定线程必须先获取资源A，再获取资源B。
遵循资源顺序：确保所有线程在获取资源时都遵循定义的资源顺序。例如，在线程1中先获取资源A，再获取资源B；在线程2中也先获取资源A，再获取资源B。
分级锁定：将资源分为不同级别，线程在获取资源时必须按照级别顺序进行。例如，将资源分为高、中、低三个级别，线程必须先获取高级别资源，再获取中级别资源，最后获取低级别资源。

使用死锁检测算法

死锁检测算法可以定期检查系统中是否存在死锁，并采取相应措施解决死锁问题。例如：

资源分配图：通过维护一个资源分配图，记录系统中线程与资源的分配情况，并定期检查是否存在循环依赖。资源分配图中，节点表示线程和资源，边表示线程请求或持有资源。
银行家算法：银行家算法是一种经典的死锁检测算法，通过模拟资源分配过程，判断系统是否处于安全状态。银行家算法需要维护一个资源分配矩阵和最大需求矩阵，并在每次资源分配时进行安全性检查。
定期检测：在系统中引入定期检测机制，定期检查系统中是否存在死锁。例如，每隔一定时间遍历所有线程和资源，检查是否存在循环依赖。如果检测到死锁，可以采取措施解除死锁，例如强制终止某些线程或释放某些资源。

具体实现案例

1. 使用无锁队列避免死锁

无锁队列是一种通过原子操作实现的线程安全数据结构，可以有效避免死锁问题。以下是一个简单的无锁队列实现示例：

#include <stdatomic.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

typedef struct {
    atomic_intptr_t head;
    atomic_intptr_t tail;
} LockFreeQueue;

void initQueue(LockFreeQueue* queue) {
    Node* dummy = (Node*)malloc(sizeof(Node));
    dummy->next = NULL;
    atomic_store(&queue->head, (intptr_t)dummy);
    atomic_store(&queue->tail, (intptr_t)dummy);
}

void enqueue(LockFreeQueue* queue, int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    Node* tail;
    while (1) {
        tail = (Node*)atomic_load(&queue->tail);
        Node* next = (Node*)atomic_load(&tail->next);
        if (tail == (Node*)atomic_load(&queue->tail)) {
            if (next == NULL) {
                if (atomic_compare_exchange_weak(&tail->next, (intptr_t*)&next, (intptr_t)newNode)) {
                    atomic_compare_exchange_weak(&queue->tail, (intptr_t*)&tail, (intptr_t)newNode);
                    return;
                }
            } else {
                atomic_compare_exchange_weak(&queue->tail, (intptr_t*)&tail, (intptr_t)next);
            }
        }
    }
}

int dequeue(LockFreeQueue* queue, int* data) {
    Node* head;
    while (1) {
        head = (Node*)atomic_load(&queue->head);
        Node* tail = (Node*)atomic_load(&queue->tail);
        Node* next = (Node*)atomic_load(&head->next);
        if (head == (Node*)atomic_load(&queue->head)) {
            if (head == tail) {
                if (next == NULL) {
                    return -1; // Queue is empty
                }
                atomic_compare_exchange_weak(&queue->tail, (intptr_t*)&tail, (intptr_t)next);
            } else {
                *data = next->data;
                if (atomic_compare_exchange_weak(&queue->head, (intptr_t*)&head, (intptr_t)next)) {
                    free(head);
                    return 0; // Dequeue successful
                }
            }
        }
    }
}

2. 使用递归锁避免嵌套锁死锁

递归锁允许同一线程多次获取同一个锁而不会导致死锁。以下是一个使用递归锁的示例：

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

pthread_mutex_t recursive_mutex;

void* threadFunc(void* arg) {
    pthread_mutex_lock(&recursive_mutex);
    printf("Thread %ld: Acquired lock\n", (long)arg);
    pthread_mutex_lock(&recursive_mutex);
    printf("Thread %ld: Acquired lock again\n", (long)arg);
    pthread_mutex_unlock(&recursive_mutex);
    printf("Thread %ld: Released lock\n", (long)arg);
    pthread_mutex_unlock(&recursive_mutex);
    printf("Thread %ld: Released lock again\n", (long)arg);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    pthread_mutex_init(&recursive_mutex, &attr);
    pthread_create(&thread1, NULL, threadFunc, (void*)1);
    pthread_create(&thread2, NULL, threadFunc, (void*)2);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&recursive_mutex);
    pthread_mutexattr_destroy(&attr);
    return 0;
}

3. 使用带超时的锁函数

带超时的锁函数允许线程在请求锁时设置超时时间，避免长时间等待导致死锁。以下是一个使用pthread_mutex_timedlock的示例：

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

pthread_mutex_t mutex;

void* threadFunc(void* arg) {
    struct timespec timeout;
    clock_gettime(CLOCK_REALTIME, &timeout);
    timeout.tv_sec += 2; // Set timeout to 2 seconds
    if (pthread_mutex_timedlock(&mutex, &timeout) == 0) {
        printf("Thread %ld: Acquired lock\n", (long)arg);
        sleep(3); // Hold the lock for 3 seconds
        pthread_mutex_unlock(&mutex);
        printf("Thread %ld: Released lock\n", (long)arg);
    } else {
        printf("Thread %ld: Failed to acquire lock (timeout)\n", (long)arg);
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&thread1, NULL, threadFunc, (void*)1);
    sleep(1); // Ensure thread1 acquires the lock first
    pthread_create(&thread2, NULL, threadFunc, (void*)2);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

通过以上几种方法和具体实现案例，我们可以有效地避免C语言中的死锁问题。在实际开发中，应根据具体情况选择合适的方法，并结合其他最佳实践，如代码审查和自动化测试，确保多线程程序的稳定性和可靠性。