C语言多线程开发中死锁与读写锁问题详解

介绍

多线程程序在共享资源的情况下容易产生各种问题。常见的问题之一是死锁和读写锁问题。本文将详细探讨这两个问题，并提供示例程序来阐述这些问题以及如何避免它们。读者需要有一定的C语言和多线程编程的基础知识。

死锁

当两个或多个线程同时尝试锁定一组资源，但是由于彼此依赖，从而导致其中一个线程等待的情况，这种情况叫做死锁。死锁是一个非常严重的问题，因为它会导致程序挂起，最终由于无法继续执行而崩溃。

示例1

下面是一个简单的死锁示例程序：

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

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void *thread1(void *arg)
{
    pthread_mutex_lock(&mutex1);
    printf("Thread 1 locked mutex 1\n");
    sleep(2);
    pthread_mutex_lock(&mutex2);
    printf("Thread 1 locked mutex 2\n");
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void *thread2(void *arg)
{
    pthread_mutex_lock(&mutex2);
    printf("Thread 2 locked mutex 2\n");
    sleep(2);
    pthread_mutex_lock(&mutex1);
    printf("Thread 2 locked mutex 1\n");
    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

int main()
{
    pthread_t t1, t2;
    pthread_create(&t1, NULL, thread1, NULL);
    pthread_create(&t2, NULL, thread2, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}

本程序中，线程1需要先锁定mutex1，然后锁定mutex2；线程2需要先锁定mutex2，然后锁定mutex1。但是由于两个线程的锁定顺序相反，所以在执行过程中可能会发生死锁。执行该程序可能会出现以下输出：

Thread 1 locked mutex 1
Thread 2 locked mutex 2
（程序阻塞）

由于线程1在持有mutex1的情况下等待mutex2，线程2在持有mutex2的情况下等待mutex1，所以程序会陷入死锁。

解决方案

避免死锁的最简单方法是按照一定的顺序锁定资源。如果程序中涉及多个资源，应该在每个线程中始终以相同的顺序锁定它们。在上述示例中，为了避免死锁，可以将线程1中的锁定顺序修改为：

pthread_mutex_lock(&mutex1);
printf("Thread 1 locked mutex 1\n");
sleep(2);
pthread_mutex_lock(&mutex2);
printf("Thread 1 locked mutex 2\n");

即在线程1中先锁定mutex1，然后再锁定mutex2。同样的，在线程2中，应该先锁定mutex1，然后再锁定mutex2。

此外，还可以使用pthread_mutex_trylock()函数来避免死锁。pthread_mutex_trylock()函数尝试锁定一个mutex，如果锁定成功则立即返回；如果失败，则不会阻塞，而是返回一个错误代码。

读写锁

读写锁是一种特殊类型的锁，可以同时允许多个读取操作，但只允许一个写入操作。读写锁适用于有大量读取操作和少量写入操作的情况。读写锁可以有效地提高程序的效率，因为它允许多个线程同时对共享资源进行读取操作，而不需要互斥锁的互斥访问。

示例2

下面是一个简单的读写锁示例程序：

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

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
int num = 0;

void *reader(void *arg)
{
    pthread_rwlock_rdlock(&rwlock);
    printf("Reader read num %d\n", num);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

void *writer(void *arg)
{
    pthread_rwlock_wrlock(&rwlock);
    printf("Writer write num %d\n", ++num);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main()
{
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, reader, NULL);
    pthread_create(&t2, NULL, reader, NULL);
    pthread_create(&t3, NULL, writer, NULL);
    pthread_create(&t4, NULL, reader, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    return 0;
}

在本程序中，运用pthread_rwlock_* 相关函数模拟了读写锁的使用。程序有三个读者线程和一个写者线程。读者线程尝试获取读取锁，并读取一个变量num的值，写者线程获取写入锁并将num加1.

解决方案

使用读写锁可以避免对共享资源的不必要互斥访问，从而提高程序的效率。更具体的方案如下：

• 对于大量的读操作，使用pthread_rwlock_rdlock()函数进行读取操作。
• 对于少量的写操作，使用pthread_rwlock_wrlock()函数进行写入操作。
• 使用pthread_rwlock_unlock()函数释放读写锁。

结论

本文介绍了死锁和读写锁，并提供了示例程序以展示这些问题和如何解决它们。在编写多线程程序时，避免死锁和充分利用读写锁是至关重要的，这有助于提高程序的效率并确保程序的正确性。开发者需要牢记这些问题，并在实际开发中加以考虑。