【Linux】多线程(自旋锁、读写锁)
🌈个人主页：秦jh__https://blog.csdn.net/qinjh_?spm=1010.2135.3001.5343
🔥 系列专栏：https://blog.csdn.net/qinjh_/category_12625432.html
目录
自旋锁
概述
原理
优点与缺点优点
使用场景
Linux提供的自旋锁系统调用
注意事项
结论
样例代码
读写锁
初始化和销毁
加锁和解锁
样例代码
读者优先
写者优先
前言
💬 hello! 各位铁子们大家好哇。
今日更新了Linux线程的内容
🎉 欢迎大家关注🔍点赞👍收藏⭐️留言📝
自旋锁
概述
自旋锁是一种多线程同步机制，用于保护共享资源免受并发访问的影响。在多个线程尝试获取锁时，它们会持续自旋（即在一个循环中不断检查锁是否可用）而不是立即进入休眠状态等待锁的释放。这种机制减少了线程切换的开销，适用于短时间内锁的竞争情况。但是不合理的使用，可能会造成 CPU 的浪费。
原理
自旋锁通常使用一个共享的标志位（如一个布尔值）来表示锁的状态。当标志位为 true 时，表示锁已被某个线程占用；当标志位为 false 时，表示锁可用。当一个线程尝试获取自旋锁时，它会不断检查标志位：
- 如果标志位为 false ，表示锁可用，线程将设置标志位为 true ，表示自己占用了锁，并进入临界区。
- 如果标志位为 true （即锁已被其他线程占用），线程会在一个循环中不断自旋等待，直到锁被释放。
优点与缺点优点
优点：
- 低延迟：自旋锁适用于短时间内的锁竞争情况，因为它不会让线程进入休眠状态，从而避免了线程切换的开销，提高了锁操作的效率。
- 减少系统调度开销：等待锁的线程不会被阻塞，不需要上下文切换，从而减少了系统调度的开销。
缺点：
- CPU资源浪费：如果锁的持有时间较长，等待获取锁的线程会一直循环等待，导致 CPU 资源的浪费。
- 可能引起活锁：当多个线程同时等待一个锁时，如果没有适当的退避策略，可能会导致所有线程都在不断检查锁状态而无法进入临界区，形成活锁。
使用场景
- 短暂等待的情况：适用于锁被占用时间很短很短的场景，如多线程对共享数据进行简单的读写操作
- 多线程锁使用：通常用于系统底层，同步多个cpu对共享资源的访问。
Linux提供的自旋锁系统调用
- int pthread_spin_lock(pthread_spinlock_t *lock);
- int pthread_spin_trylock(pthread_spinlock_t *lock);
- int pthread_spin_unlock(pthread_spinlock_t *lock);
- int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
- pshared有两个选项，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。private选项表示自旋锁只能在同一进程内的多个线程内使用。pshared表示可以在多个不同的进程内使用同一个自旋锁。
- int pthread_spin_destroy(pthread_spínlock_t *lock );
注意事项
- 在使用自旋锁时，需要确保锁被释放的时间尽可能短，以避免 CPU 资源的浪费。
- 在多 CPU 环境下，自旋锁可能不如其他锁机制高效，因为它可能导致线程在不同的 CPU 上自旋等待。
结论
自旋锁是一种适用于短时间内锁竞争情况的同步机制，它通过减少线程切换的开销来提高锁操作的效率。然而，它也存在 CPU 资源浪费和可能引起活锁等缺点。在使用自旋锁时，需要根据具体的应用场景进行选择，并确保锁被释放的时间尽可能短。
样例代码
#include
#include
#include
#include
#include
int ticket = 1000;
pthread_spinlock_t lock;
void *route(void *arg)
{
char *id = (char *)arg;
while (1)
{
pthread_spin_lock(&lock);
if (ticket > 0)
{
usleep(1000);
printf("%s sells ticket:%d
", id, ticket);
ticket--;
pthread_spin_unlock(&lock);
}
else
{
pthread_spin_unlock(&lock);
break;
}
}
return nullptr;
}
int main(void)
{
pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
pthread_t t1, t2, t3, t4;
pthread_create(&t1, NULL, route, (void *)"thread 1");
pthread_create(&t2, NULL, route, (void *)"thread 2");
pthread_create(&t3, NULL, route, (void *)"thread 3");
pthread_create(&t4, NULL, route, (void *)"thread 4");
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_join(t3, NULL);
pthread_join(t4, NULL);
pthread_spin_destroy(&lock);
return 0;
} 读写锁
在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？ 有，那就是读写锁。
注意：写独占，读共享，读锁优先级高
读者和读者是并发关系，写者和写者是互斥，读者和写者是互斥&&同步。
pthread库里面给我们提供了读写锁。
初始化和销毁
加锁和解锁
rd是以读者身份加锁，wr是以写者身份加锁。
解锁都用同一个函数解锁。
样例代码
#include
#include
#include
#include
#include
#include
// 共享资源
int shared_data = 0;
// 读写锁
pthread_rwlock_t rwlock;
// 读者线程函数
void *Reader(void *arg)
{
//sleep(1); //读者优先，一旦读者进入&&读者很多，写者基本就很难进入了
int number = *(int *)arg;
while (true)
{
pthread_rwlock_rdlock(&rwlock); // 读者加锁
std::cout << "读者-" << number << " 正在读取数据, 数据是: " << shared_data << std::endl;
sleep(1); // 模拟读取操作
pthread_rwlock_unlock(&rwlock); // 解锁
}
delete (int*)arg;
return NULL;
}
// 写者线程函数
void *Writer(void *arg)
{
int number = *(int *)arg;
while (true)
{
pthread_rwlock_wrlock(&rwlock); // 写者加锁
shared_data = rand() % 100; // 修改共享数据
std::cout << "写者- " << number << " 正在写入. 新的数据是: " << shared_data << std::endl;
sleep(2); // 模拟写入操作
pthread_rwlock_unlock(&rwlock); // 解锁
}
delete (int*)arg;
return NULL;
}
int main()
{
srand(time(nullptr)^getpid());
pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁
// 可以更高读写数量配比，观察现象
const int reader_num = 2;
const int writer_num = 2;
const int total = reader_num + writer_num;
pthread_t threads[total]; // 假设读者和写者数量相等
// 创建读者线程
for (int i = 0; i < reader_num; ++i)
{
int *id = new int(i);
pthread_create(&threads[i], NULL, Reader, id);
}
// 创建写者线程
for (int i = reader_num; i < total; ++i)
{
int *id = new int(i - reader_num);
pthread_create(&threads[i], NULL, Writer, id);
}
// 等待所有线程完成
for (int i = 0; i < total; ++i)
{
pthread_join(threads[i], NULL);
}
pthread_rwlock_destroy(&rwlock); // 销毁读写锁
return 0;
}
读者优先
在这种策略中，系统会尽可能多地允许多个读者同时访问资源（比如共享文件或数据），而不会优先考虑写者。这意味着当有读者正在读取时，新到达的读者会立即被允许进入读取区，而写者则会被阻塞，直到所有读者都离开读取区。读者优先策略可能会导致写者饥饿（即写者长时间无法获得写入权限），特别是当读者频繁到达时。
写者优先
在这种策略中，系统会优先考虑写者。当写者请求写入权限时，系统会尽快地让写者进入写入区，即使此时有读者正在读取。这通常意味着一旦有写者到达，所有后续的读者都会被阻塞，直到写者完成写入并离开写入区。写者优先策略可以减少写者等待的时间，但可能会导致读者饥饿（即读者长时间无法获得读取权限），特别是当写者频繁到达时。
