并发锁怎么用

并发锁是一种用于控制多个线程或进程对共享资源的访问的机制，以避免数据竞争和不一致性。以下是使用并发锁的一些基本步骤：

1. 选择合适的锁类型

• 互斥锁（Mutex）：确保同一时间只有一个线程可以访问资源。
• 读写锁（ReadWrite Lock）：允许多个线程同时读取资源，但只允许一个线程写入资源。
• 自旋锁（Spinlock）：线程在等待锁时不会放弃CPU，适用于锁持有时间短的场景。
• 条件变量（Condition Variable）：与锁配合使用，允许线程在特定条件下等待和通知。

2. 初始化锁

在程序开始时初始化锁。

#include <pthread.h>

pthread_mutex_t mutex;
pthread_rwlock_t rwlock;

void init_locks() {
    pthread_mutex_init(&mutex, NULL);
    pthread_rwlock_init(&rwlock, NULL);
}

3. 加锁

在访问共享资源之前加锁。

互斥锁

void critical_section() {
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
}

读写锁

void read_resource() {
    pthread_rwlock_rdlock(&rwlock);
    // 读取共享资源
    pthread_rwlock_unlock(&rwlock);
}

void write_resource() {
    pthread_rwlock_wrlock(&rwlock);
    // 写入共享资源
    pthread_rwlock_unlock(&rwlock);
}

4. 解锁

在访问完共享资源后解锁。

void critical_section() {
    pthread_mutex_lock(&mutex);
    // 访问共享资源
    pthread_mutex_unlock(&mutex);
}

5. 销毁锁

在程序结束时销毁锁。

void cleanup_locks() {
    pthread_mutex_destroy(&mutex);
    pthread_rwlock_destroy(&rwlock);
}

6. 处理死锁

• 避免嵌套锁：尽量避免在一个锁的保护范围内获取另一个锁。
• 使用超时机制：在获取锁时设置超时时间，防止无限等待。
• 资源分级：按照固定的顺序获取多个锁。

示例代码

以下是一个简单的示例，展示了如何使用互斥锁保护共享资源。

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

#define NUM_THREADS 5

int shared_resource = 0;
pthread_mutex_t mutex;

void* increment_resource(void* arg) {
    for (int i = 0; i < 100000; ++i) {
        pthread_mutex_lock(&mutex);
        shared_resource++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];

    init_locks();

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_create(&threads[i], NULL, increment_resource, NULL);
    }

    for (int i = 0; i < NUM_THREADS; ++i) {
        pthread_join(threads[i], NULL);
    }

    printf("Final value of shared_resource: %d\n", shared_resource);

    cleanup_locks();

    return 0;
}

在这个示例中，多个线程并发地增加一个共享变量 shared_resource，使用互斥锁确保每次只有一个线程可以访问该变量，从而避免数据竞争。

通过遵循这些步骤和注意事项，你可以有效地使用并发锁来保护共享资源，确保程序的正确性和可靠性。