【Linux】：多线程（读写锁 && 自旋锁）

原型：
int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);

参数：
 rwlock: 指向 pthread_rwlock_t 类型的读写锁对象的指针。
 attr: 一个指向 pthread_rwlockattr_t 类型的指针，可以设置锁的属性。
     如果不需要特定的属性，通常可以将其设置为 NULL。

返回值：
返回 0 表示成功，返回错误码（如 EINVAL）表示初始化失败。

范例：
#include <pthread.h>
#include <stdio.h>

pthread_rwlock_t rwlock;

int main() {
    // 初始化读写锁
    if (pthread_rwlock_init(&rwlock, NULL) != 0) {
        perror("pthread_rwlock_init");
        return 1;
    }

    // 后续可以使用 rwlock 执行读写操作

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

    return 0;
}

原型：
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

参数：
rwlock: 指向要获取读锁的 pthread_rwlock_t 类型的读写锁对象。
返回值：

返回 0 表示成功，返回错误码表示失败（例如 EBUSY 表示写锁被持有，当前线程无法获得读锁）

范例：
#include <pthread.h>
#include <stdio.h>

pthread_rwlock_t rwlock;

void* read_data(void* arg) {
    pthread_rwlock_rdlock(&rwlock);  // 获取读锁
    printf("Reading data...\n");
    pthread_rwlock_unlock(&rwlock);  // 释放读锁
    return NULL;
}

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

    pthread_t threads[3];
    for (int i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, read_data, NULL);
    }

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

    pthread_rwlock_destroy(&rwlock);  // 销毁读写锁
    return 0;
}
// 在上述代码中，多个线程可以同时获得读锁并执行读取操作，而无需相互阻塞。

原型：
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

参数：
rwlock: 指向要获取写锁的 pthread_rwlock_t 类型的读写锁对象。

返回值：
返回 0 表示成功，返回错误码表示失败如: EBUSY 表示有其他线程持有读锁或写锁，当前线程无法获得写锁

范例：
#include <pthread.h>
#include <stdio.h>

pthread_rwlock_t rwlock;

void* write_data(void* arg) {
    pthread_rwlock_wrlock(&rwlock);  // 获取写锁
    printf("Writing data...\n");
    pthread_rwlock_unlock(&rwlock);  // 释放写锁
    return NULL;
}

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

    pthread_t threads[2];
    for (int i = 0; i < 2; i++) {
        pthread_create(&threads[i], NULL, write_data, NULL);
    }

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

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

// 在上面的示例中，write_data 函数每次都获取写锁，并在完成写操作后释放写锁。
// 在写操作期间，不允许其他线程获取读锁或写锁

原型：
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

参数：
rwlock: 指向需要释放锁的 pthread_rwlock_t 类型的读写锁对象。

返回值：
返回 0 表示成功，返回错误码表示失败（例如 EINVAL 表示锁没有被当前线程持有）

#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)
{
    // slee(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;
}

#include <stdio.h>
#include <stdatomic.h>
#include <pthread.h>
#include <unistd.h>
// 使用原子标志来模拟自旋锁
atomic_flag spinlock = ATOMIC_FLAG_INIT; // ATOMIC_FLAG_INIT 是 0
// 尝试获取锁
void spinlock_lock() {
	while (atomic_flag_test_and_set(&spinlock)) {
		// 如果锁被占用，则忙等待
	}
}
// 释放锁
void spinlock_unlock() {
	atomic_flag_clear(&spinlock);
}


typedef _Atomic struct
{
#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
	_Bool __val;
#else
	unsigned char __val;
#endif
}atomic_flag;

#include <pthread.h>

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);
int pthread_spin_destroy(pthread_spinlock_t *lock);

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>

int ticket = 1000;
pthread_spinlock_t lock;

void *routine(void *arg)
{
    char *id = (char*)arg;
    while(1){
        if (ticket > 0){
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
        }
        else{
            break;
        }
    }
    return nullptr;
}

int main(){
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, routine, (void *) "thread-1");
    pthread_create(&t2, NULL, routine, (void *) "thread-2");
    pthread_create(&t3, NULL, routine, (void *) "thread-3");
    pthread_create(&t4, NULL, routine, (void *) "thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>

int ticket = 1000;
pthread_spinlock_t lock;

void *routine(void *arg)
{
    char *id = (char*)arg;
    while(1)
    {
        pthread_spin_lock(&lock);
        if (ticket > 0)
        {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
            pthread_spin_unlock(&lock);
        }
        else{
            pthread_spin_unlock(&lock);
            break;
        }
    }
    return nullptr;
}


int main()
{
    pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
    pthread_t t1, t2, t3, t4;

    pthread_create(&t1, NULL, routine, (void *) "thread-1");
    pthread_create(&t2, NULL, routine, (void *) "thread-2");
    pthread_create(&t3, NULL, routine, (void *) "thread-3");
    pthread_create(&t4, NULL, routine, (void *) "thread-4");

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);

    return 0;
}