【在Linux世界中追寻伟大的One Piece】读者写者问题与读写锁

uint32_t reader_count = 0;
lock_t count_lock;
lock_t writer_lock;

// 加锁
lock(count_lock);
if (reader_count == 0)
	lock(writer_lock);
++reader_count;
unlock(count_lock);

// read;
//解锁
lock(count_lock);
--reader_count;
if (reader_count == 0)
	unlock(writer_lock);
unlock(count_lock);

lock(writer_lock);

// write
unlock(writer_lock);

int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t* attr, int pref);
/*
pref 共有 3 种选择
PTHREAD_RWLOCK_PREFER_READER_NP (默认设置) 读者优先，可能会导致写者饥饿情况
PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先，目前有 BUG，导致表现行为和PTHREAD_RWLOCK_PREFER_READER_NP 一致
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先，但写者不能递归加锁
*/

int pthread_rwlock_init(pthread_rwlock_t* restrict rwlock, const pthread_rwlockattr_t* restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <cstdlib>
#include <ctime>

// 共享资源
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;
}