当前位置：首页 > news >正文

【Linux系统编程】：自旋锁，读写锁

news 来源：原创 2025/5/10 0:21:03

文章目录

前言
1. POSIX自旋锁
- - 1.1.定义自旋锁
  - 1.2.初始化
  - 1.3. 加锁
  - 1.4. 尝试加锁操作
  - 1.5. 解锁操作
  - 1.6. 销毁操作
  - 1.7.示例
  - 1.8.优缺点
  - - 优点
    - 缺点
  - 1.9.适用场景
2. 读写锁
- 2.1 读写锁的工作原理
- 2.2 读写模型
- 2.3 常用接口
- - 2.3.1 定义锁并初始化
  - 2.3.2 申请读锁
  - 2.3.3 申请写锁
  - 2.3.4 解锁
  - 2.3.5 销毁锁
  - 2.3.6 设置优先级
  - 2.3.7 示例

前言

前面我们所谈论的锁，都是挂起等待锁，也就是当线程获取已经被持有的“挂起等待锁”时，会被操作系统挂起（陷入阻塞状态并加入等待队列中），但自旋锁不会。
自旋锁是一种忙等待锁，当一个线程尝试获取自旋锁时，如果锁当前已经被其他线程持有，该线程不会进入睡眠状态，而是会持续检查锁的状态，直到获取到锁为止。这种持续的检查过程就像在 “自旋” 一样，因此被称为自旋锁。pthread_mutex_trylock
如果我们想在应用层做一个自旋锁，可以用互斥量的接口pthread_mutex_trylock, 在这里插入图片描述
工作原理：

我们只要将pthread_mutex_trylock放在一个循环里，就可以实现“自旋锁”。我们也可以不用互斥量，因为POSIX线程库提供了自旋锁相关接口。

1. POSIX自旋锁

1.1.定义自旋锁

pthread_spinlock_t 是 POSIX 线程库中用于实现自旋锁的数据类型。在使用自旋锁前，我们先要定义一把。

#include <pthread.h>
pthread_spinlock_t slock;

1.2.初始化

在使用自旋锁之前，需要对其进行初始化：

#include <pthread.h>int pthread_spin_init(pthread_spinlock_t *lock, int pshared);

参数：
- lock：指向 pthread_spinlock_t 类型的指针，表示要初始化的自旋锁。
- pshared：指定自旋锁的共享属性，有两个可选值：
  - PTHREAD_PROCESS_SHARED：表示该自旋锁可以在多个进程间共享。
  - PTHREAD_PROCESS_PRIVATE：表示该自旋锁只能在同一进程内的多个线程间使用，这是比较常见的用法。
返回值：如果初始化成功，返回 0；如果出现错误，返回相应的错误码。

1.3. 加锁

int pthread_spin_lock(pthread_spinlock_t *lock);

该函数用于尝试获取指定的自旋锁。如果锁当前未被其他线程持有，调用线程会立即获取锁并继续执行；如果锁已经被其他线程持有，调用线程会进入自旋状态，不断检查锁的状态，直到成功获取锁。返回值为 0 表示成功获取锁，出现错误时返回相应的错误码。

1.4. 尝试加锁操作

int pthread_spin_trylock(pthread_spinlock_t *lock);

这是一个非阻塞的加锁操作。如果锁当前未被其他线程持有，调用线程会立即获取锁并返回 0；如果锁已经被其他线程持有，函数会立即返回 EBUSY，而不会让线程进入自旋状态。同样，出现其他错误时返回相应的错误码。

1.5. 解锁操作

int pthread_spin_unlock(pthread_spinlock_t *lock);

该函数用于释放指定的自旋锁。调用线程必须是当前持有该自旋锁的线程，释放锁后，其他等待该锁的线程有机会获取它。返回值为 0 表示解锁成功，出现错误时返回相应的错误码。

1.6. 销毁操作

int pthread_spin_destroy(pthread_spinlock_t *lock);

当自旋锁不再使用时，需要调用该函数进行销毁，释放相关资源。返回值为 0 表示销毁成功，出现错误时返回相应的错误码。

1.7.示例

#include <stdio.h>
#include <pthread.h>pthread_spinlock_t spinlock;
int shared_variable = 0;void* thread_function(void* arg) {pthread_spin_lock(&spinlock);// 临界区，对共享资源进行操作shared_variable++;printf("Thread %ld: shared_variable = %d\n", (long)arg, shared_variable);pthread_spin_unlock(&spinlock);return NULL;
}int main() {pthread_t threads[2];// 初始化自旋锁pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE);for (long i = 0; i < 2; i++) {pthread_create(&threads[i], NULL, thread_function, (void*)i);}for (int i = 0; i < 2; i++) {pthread_join(threads[i], NULL);}// 销毁自旋锁pthread_spin_destroy(&spinlock);return 0;
}

在上述代码中，首先使用 pthread_spin_init 初始化自旋锁，然后创建两个线程，每个线程在进入临界区前调用 pthread_spin_lock 获取锁，对共享变量 shared_variable 进行操作，操作完成后调用 pthread_spin_unlock 释放锁。最后，使用 pthread_spin_destroy 销毁自旋锁。

1.8.优缺点

优点

低延迟：在锁被持有的时间较短的情况下，自旋锁的性能优势明显。由于线程不需要进行上下文切换，避免了睡眠和唤醒的开销，能够快速获取锁并继续执行，从而提供较低的延迟。
实现简单：自旋锁的实现相对简单，不需要复杂的操作系统调度机制支持，只需要使用原子操作来实现锁的状态检查和设置。

缺点

CPU 资源浪费：如果锁被持有的时间较长，自旋的线程会持续占用 CPU 资源进行空转，导致 CPU 资源的浪费，降低系统的整体性能。
可能导致优先级反转：在某些情况下，可能会出现优先级反转问题。例如，低优先级的线程持有自旋锁，高优先级的线程需要该锁，高优先级线程会自旋等待，导致低优先级线程无法及时执行完并释放锁，从而影响系统的实时性。

1.9.适用场景

锁持有时间短：自旋锁适用于锁被持有的时间非常短的场景，例如对某个共享变量进行简单的读写操作。在这种情况下，线程自旋等待的时间不会太长，不会造成过多的 CPU 资源浪费。
多核系统：在多核系统中，多个线程可以并行执行，自旋的线程可以在其他 CPU 核心上继续自旋，而不会阻塞整个系统。因此，自旋锁在多核系统中更为适用。
来源：https://www.doubao.com/chat/

2. 读写锁

在编写多线程的时候，可能会出现线程间对于临界资源的访问需求要远远大于修改需求，访问的频率远远高于修改的频率，而访问往往伴随着查找的操作，给这种临界区加锁，可能会极大地降低程序运行效率。那么有没有一种锁，专门处理这种多访问少修改的情况呢？有，那就是读写锁。

2.1 读写锁的工作原理

当多个线程同时对共享资源进行读操作时，一般不会出现数据竞争问题，而线程进行写操作时，必须保证只有当前唯一一个线程进行写操作，且其他线程无法进行读操作，以确保数据的一致性。
因此，读写锁允许多个线程同时获取读锁进行读操作，但在有线程持有写锁时，其他线程不能获取读锁或写锁；同样，当有线程持有读锁时，其他线程不能获取写锁。

2.2 读写模型

多线程间的多访问少修改，访问对于读，修改对应写，针对这种场景，我们假想出一种读写模型（类似于CP模型，具体的应用就是读写锁。），该模型中存在三个关系两个角色一个场所。
在这里插入图片描述
问题来了，为什么读写模型中，读与读之间是“共享”的，可以并发进行，而CP模型中，消费与消费之间却是互斥的？
因为读数据没有修改临界资源，而消费数据修改了临界资源。所以我们只要关注写之间的互斥以及读写之间的互斥和同步。
在读写模型中，由于读的线程较多以及读的频率较高，在竞争锁时，写的线程容易竞争不过从而产生饥饿。

2.3 常用接口

2.3.1 定义锁并初始化

静态初始化（在编译时就确定读写锁初始状态）

#include <pthread.h>
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

动态初始化

#include <pthread.h>pthread_rwlock_t rwlock;
int ret = pthread_rwlock_init(&rwlock, NULL);
if (ret != 0) {// 处理初始化失败的情况
}

pthread_rwlock_init函数的第一个参数是指向读写锁的指针；
第二个参数是指向读写锁属性对象的指针，传入NULL表示使用默认属性。

2.3.2 申请读锁

 请求读锁（共享）
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
//如果当前没有线程持有写锁，调用线程可以立即获取读锁并继续执行；
//若有线程持有写锁，调用线程会被阻塞，直到写锁被释放。//尝试非阻塞加锁（读）
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
//若当前没有线程持有写锁，调用线程能立即获取读锁并返回0；
//若有线程持有写锁，函数会立即返回EBUSY，线程不会阻塞。

2.3.3 申请写锁

//请求写锁（独占）
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
/尝试非阻塞加锁（写）
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

2.3.4 解锁

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

2.3.5 销毁锁

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

2.3.6 设置优先级

在 POSIX 线程库中，读写锁的属性可以通过属性对象来进行设置和管理。pthread_rwlockattr_setkind_np 函数用于设置读写锁的竞争策略，也就是当有读线程和写线程同时竞争读写锁时，决定哪个线程优先获取锁。这里的 “np” 通常表示 “non - portable”（非移植性），意味着这个函数不是 POSIX 标准的一部分，不同的操作系统实现可能会有所不同。详情参考https://www.doubao.com/chat/。

2.3.7 示例

#include <vector>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <pthread.h>
#include <atomic>  // 使用 std::atomic 来保证线程安全// 使用 std::atomic 来保证对 ticket 的操作是线程安全的
std::atomic<int> ticket(1000);
pthread_rwlock_t rwlock;// 读者线程函数
void *reader(void *arg) {// 将传入的 void* 指针转换为 std::string*std::string *id = static_cast<std::string*>(arg);while (true) {// 获取读锁pthread_rwlock_rdlock(&rwlock);// 检查 ticket 是否小于等于 0if (ticket.load() <= 0) {// 释放读锁pthread_rwlock_unlock(&rwlock);break;}// 打印当前 ticket 值printf("%s: %d\n", id->c_str(), ticket.load());// 释放读锁pthread_rwlock_unlock(&rwlock);// 休眠 1 微秒usleep(1);}// 释放分配的内存delete id;return nullptr;
}// 写者线程函数
void *writer(void *arg) {// 将传入的 void* 指针转换为 std::string*std::string *id = static_cast<std::string*>(arg);while (true) {// 获取写锁pthread_rwlock_wrlock(&rwlock);// 检查 ticket 是否小于等于 0if (ticket.load() <= 0) {// 释放写锁pthread_rwlock_unlock(&rwlock);break;}// 打印当前 ticket 值并递减 ticketprintf("%s: %d\n", id->c_str(), ticket.fetch_sub(1));// 释放写锁pthread_rwlock_unlock(&rwlock);// 休眠 1 微秒usleep(1);}// 释放分配的内存delete id;return nullptr;
}// 线程属性结构体
struct ThreadAttr {pthread_t tid;  // 线程 IDstd::string id; // 线程标识符
};// 创建读者线程标识符
std::string create_reader_id(std::size_t i) {// 使用 ostringstream 进行 string 拼接std::ostringstream oss;oss << "thread reader " << i;return oss.str();
}// 创建写者线程标识符
std::string create_writer_id(std::size_t i) {// 使用 ostringstream 进行 string 拼接std::ostringstream oss;oss << "thread writer " << i;return oss.str();
}// 初始化读者线程
void init_readers(std::vector<ThreadAttr>& vec) {for (std::size_t i = 0; i < vec.size(); ++i) {vec[i].id = create_reader_id(i);// 动态分配内存并传递给线程函数std::string *id = new std::string(vec[i].id);pthread_create(&vec[i].tid, nullptr, reader, id);}
}// 初始化写者线程
void init_writers(std::vector<ThreadAttr>& vec) {for (std::size_t i = 0; i < vec.size(); ++i) {vec[i].id = create_writer_id(i);// 动态分配内存并传递给线程函数std::string *id = new std::string(vec[i].id);pthread_create(&vec[i].tid, nullptr, writer, id);}
}// 回收线程
void join_threads(const std::vector<ThreadAttr>& vec) {// 按创建的顺序回收线程for (const auto& ta : vec) {void *id = nullptr;pthread_join(ta.tid, &id);// 释放传递给线程的内存delete static_cast<std::string*>(id);}
}// 初始化读写锁
void init_rwlock() {
#if 0   // 写优先pthread_rwlockattr_t attr;pthread_rwlockattr_init(&attr);pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);pthread_rwlock_init(&rwlock, &attr);pthread_rwlockattr_destroy(&attr);
#else   // 读优先，会造成写饥饿pthread_rwlock_init(&rwlock, nullptr);
#endif
}int main() {// 测试效果不明显的情况下，可以加大 reader_nr// 但也不能太大，超过一定阈值后系统就调度不了主线程了const std::size_t reader_nr = 1000;const std::size_t writer_nr = 2;std::vector<ThreadAttr> readers(reader_nr);std::vector<ThreadAttr> writers(writer_nr);init_rwlock();init_readers(readers);init_writers(writers);join_threads(writers);join_threads(readers);pthread_rwlock_destroy(&rwlock);return 0;
}