Linux互斥锁与读写锁

Linux线程互斥锁、读写锁是用来保护共享资源，防止多个线程同时访问共享资源而导致数据不一致的情况发生。下面是一个详细的教程，介绍如何在Linux系统中使用线程互斥锁和读写锁。

1. 互斥锁（Mutex）

互斥锁是最基本的线程同步机制，它可以确保在任意时刻只有一个线程可以访问共享资源。在Linux系统中，可以使用pthread库中的pthread_mutex_t类型来创建和操作互斥锁。

首先，需要包含pthread库的头文件：
 

#include <pthread.h>

然后，可以使用pthread_mutex_t类型来声明一个互斥锁变量，并使用pthread_mutex_init函数来初始化互斥锁：

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

在需要保护共享资源的地方，可以使用pthread_mutex_lock函数来加锁，以防止其他线程同时访问：

pthread_mutex_lock(&mutex);
// 访问共享资源的代码
pthread_mutex_unlock(&mutex);

最后，使用pthread_mutex_destroy函数来销毁互斥锁：

pthread_mutex_destroy(&mutex);

2. 读写锁（ReadWrite Lock）

读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。在Linux系统中，可以使用pthread库中的pthread_rwlock_t类型来创建和操作读写锁。

首先，需要包含pthread库的头文件：

#include <pthread.h>

然后，可以使用pthread_rwlock_t类型来声明一个读写锁变量，并使用pthread_rwlock_init函数来初始化读写锁：

pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);

在需要读取共享资源的地方，可以使用pthread_rwlock_rdlock函数来加读锁：

pthread_rwlock_rdlock(&rwlock);
// 读取共享资源的代码
pthread_rwlock_unlock(&rwlock);

在需要写入共享资源的地方，可以使用pthread_rwlock_wrlock函数来加写锁：

pthread_rwlock_wrlock(&rwlock);
// 写入共享资源的代码
pthread_rwlock_unlock(&rwlock);

最后，使用pthread_rwlock_destroy函数来销毁读写锁：

pthread_rwlock_destroy(&rwlock);

当使用互斥锁时，需要确保在访问共享资源之前先锁定互斥锁，在访问完毕后再解锁互斥锁。下面是一个简单的C语言代码例程，演示了如何使用互斥锁来保护共享资源：

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

// 共享资源
int shared_resource = 0;

// 互斥锁
pthread_mutex_t mutex;

// 线程函数
void *thread_function(void *arg) {
    // 加锁
    pthread_mutex_lock(&mutex);

    // 访问共享资源
    shared_resource++;
    printf("Thread %d: Shared resource value: %d\n", (int)arg, shared_resource);

    // 解锁
    pthread_mutex_unlock(&mutex);

    return NULL;
}

int main() {
    pthread_t thread1, thread2;

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

    // 创建线程1
    pthread_create(&thread1, NULL, thread_function, (void*)1);
    // 创建线程2
    pthread_create(&thread2, NULL, thread_function, (void*)2);

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

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

    return 0;
}

在上面的例程中，我们首先初始化了一个互斥锁，并在 thread_function 函数中使用 pthread_mutex_lock 和 pthread_mutex_unlock 来保护共享资源 shared_resource。在 main 函数中，我们创建了两个线程来访问共享资源，并在最后销毁了互斥锁。

如果需要同时读取和写入多个变量，可以使用读写锁（ReadWrite Lock）来实现。读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。下面是一个简单的C语言代码例程，演示了如何使用读写锁来保护多个变量的读写操作：

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

// 共享资源
int var1 = 0;
int var2 = 0;

// 读写锁
pthread_rwlock_t rwlock;

// 线程函数（读取共享资源）
void *reader_thread_function(void *arg) {
    pthread_rwlock_rdlock(&rwlock);

    // 读取共享资源
    printf("Reader Thread: var1 = %d, var2 = %d\n", var1, var2);

    pthread_rwlock_unlock(&rwlock);

    return NULL;
}

// 线程函数（写入共享资源）
void *writer_thread_function(void *arg) {
    pthread_rwlock_wrlock(&rwlock);

    // 写入共享资源
    var1++;
    var2++;
    printf("Writer Thread: var1 = %d, var2 = %d\n", var1, var2);

    pthread_rwlock_unlock(&rwlock);

    return NULL;
}

int main() {
    pthread_t reader_thread, writer_thread;

    // 初始化读写锁
    pthread_rwlock_init(&rwlock, NULL);

    // 创建读取共享资源的线程
    pthread_create(&reader_thread, NULL, reader_thread_function, NULL);
    // 创建写入共享资源的线程
    pthread_create(&writer_thread, NULL, writer_thread_function, NULL);

    // 等待线程结束
    pthread_join(reader_thread, NULL);
    pthread_join(writer_thread, NULL);

    // 销毁读写锁
    pthread_rwlock_destroy(&rwlock);

    return 0;
}

在上面的例程中，我们首先初始化了一个读写锁，并在 reader_thread_function 和 writer_thread_function 函数中使用 pthread_rwlock_rdlock、pthread_rwlock_wrlock 和 pthread_rwlock_unlock 来保护共享资源 var1 和 var2。在 main 函数中，我们创建了一个读取共享资源的线程和一个写入共享资源的线程，并在最后销毁了读写锁。

如果多个线程一次只能读写其中一个变量，并且一个线程在修改变量时，其他线程也能修改另一个变量，你可以考虑使用多个读写锁来保护不同的变量。这样可以确保每个变量的读写操作都能独立进行，而不会被其他线程的读写操作所阻塞。

下面是一个简单的C语言代码例程，演示了如何使用多个读写锁来保护不同的变量的读写操作：

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

// 共享资源
int var1 = 0;
int var2 = 0;

// 读写锁
pthread_rwlock_t rwlock1;
pthread_rwlock_t rwlock2;

// 线程函数（读取共享资源1）
void *reader_thread_function1(void *arg) {
    pthread_rwlock_rdlock(&rwlock1);

    // 读取共享资源1
    printf("Reader Thread 1: var1 = %d\n", var1);

    pthread_rwlock_unlock(&rwlock1);

    return NULL;
}

// 线程函数（读取共享资源2）
void *reader_thread_function2(void *arg) {
    pthread_rwlock_rdlock(&rwlock2);

    // 读取共享资源2
    printf("Reader Thread 2: var2 = %d\n", var2);

    pthread_rwlock_unlock(&rwlock2);

    return NULL;
}

// 线程函数（写入共享资源1）
void *writer_thread_function1(void *arg) {
    pthread_rwlock_wrlock(&rwlock1);

    // 写入共享资源1
    var1++;
    printf("Writer Thread 1: var1 = %d\n", var1);

    pthread_rwlock_unlock(&rwlock1);

    return NULL;
}

// 线程函数（写入共享资源2）
void *writer_thread_function2(void *arg) {
    pthread_rwlock_wrlock(&rwlock2);

    // 写入共享资源2
    var2++;
    printf("Writer Thread 2: var2 = %d\n", var2);

    pthread_rwlock_unlock(&rwlock2);

    return NULL;
}

int main() {
    pthread_t reader_thread1, reader_thread2, writer_thread1, writer_thread2;

    // 初始化读写锁
    pthread_rwlock_init(&rwlock1, NULL);
    pthread_rwlock_init(&rwlock2, NULL);

    // 创建读取共享资源的线程
    pthread_create(&reader_thread1, NULL, reader_thread_function1, NULL);
    pthread_create(&reader_thread2, NULL, reader_thread_function2, NULL);
    // 创建写入共享资源的线程
    pthread_create(&writer_thread1, NULL, writer_thread_function1, NULL);
    pthread_create(&writer_thread2, NULL, writer_thread_function2, NULL);

    // 等待线程结束
    pthread_join(reader_thread1, NULL);
    pthread_join(reader_thread2, NULL);
    pthread_join(writer_thread1, NULL);
    pthread_join(writer_thread2, NULL);

    // 销毁读写锁
    pthread_rwlock_destroy(&rwlock1);
    pthread_rwlock_destroy(&rwlock2);

    return 0;
}