【Linux】：多线程（POSIX 信号量 、基于环形队列的生产消费者模型）

#include <semaphore.h>

① 初始化信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数：
    sem：把信号量的地址传进来
    pshared:0表示线程间共享，非零表示进程间共享
    value：信号量初始值  
② 销毁信号量 
int sem_destroy(sem_t *sem); 

③ 等待信号量
int sem_wait(sem_t *sem); //P()
功能：等待信号量，会将信号量的值减1
--就是对信号量进行申请，如果申请成功，该函数就会立即返回，并且代码继续往后走。如果不成功，即信号量不足了，就会被阻塞在这里。

④ 发布信号量
int sem_post(sem_t *sem); //V()
功能：发布信号量，表⽰资源使⽤完毕，可以归还资源了。将信号量值加1。

1. 创建信号量：
 sem_t *sem = sem_open("/my_semaphore", O_CREAT, 0644, 1);
    "/my_semaphore" 是信号量的名字。
    O_CREAT 表示创建信号量。
    0644 是权限位。
    1 是信号量的初始值。

2. P 操作：
 sem_wait(sem);

3. V 操作：
 sem_post(sem);

4. 关闭和删除信号量：
 sem_close(sem); sem_unlink("/my_semaphore");

1. 初始化信号量：
 sem_t sem; sem_init(&sem, 0, 1);
    &sem 是信号量指针。
    0 表示信号量用于线程间同步（1 表示进程间同步）。
    1 是信号量的初始值。

2. P 操作：
 sem_wait(&sem);

3. V 操作：
 sem_post(&sem);

4. 销毁信号量：
 sem_destroy(&sem);

#include <stdio.h>
#include <semaphore.h>
#include <fcntl.h>   // O_CREAT
#include <unistd.h>  // sleep

int main() {
    sem_t *sem = sem_open("/my_semaphore", O_CREAT, 0644, 1);

    if (sem == SEM_FAILED) {
        perror("sem_open failed");
        return 1;
    }

    printf("Waiting on semaphore...\n");
    sem_wait(sem);

    printf("Critical section\n");
    sleep(2);  // Simulate work

    printf("Exiting critical section\n");
    sem_post(sem);

    sem_close(sem);
    sem_unlink("/my_semaphore");

    return 0;
}

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

sem_t sem;

void* thread_func(void* arg) {
    sem_wait(&sem);
    printf("Thread %d in critical section\n", *(int*)arg);
    sleep(1);  // Simulate work
    printf("Thread %d exiting critical section\n", *(int*)arg);
    sem_post(&sem);
    return NULL;
}

int main() {
    sem_init(&sem, 0, 1);

    pthread_t t1, t2;
    int id1 = 1, id2 = 2;

    pthread_create(&t1, NULL, thread_func, &id1);
    pthread_create(&t2, NULL, thread_func, &id2);

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

    sem_destroy(&sem);

    return 0;
}

生产者
int tail = 0;
P(空间)

// 给生产者空间，放入数据
ring[tail] = data;
tail++;

V(数据)



消费者
int head = 0;
P(数据)

// 给生产者空间，放入数据
int data = ring[head];
head++;

V(空间)

#pragma once

#include <semaphore.h>

namespace SemModule
{
    int defalutsemval = 1;
    class Sem
    {
    public:
        Sem(int value = defalutsemval):_init_value(1)
        {
            int n = ::sem_init(&_sem, 0, _init_value);
            (void)n;
        }

        void P()
        {
            int n = ::sem_wait(&_sem);
            (void)n;
        }

        void V()
        {
            int n = ::sem_post(&_sem);
            (void)n;
        }

        ~Sem()
        {
            int n = ::sem_destroy(&_sem);
            (void)n;
        }
    private:
        sem_t _sem;
        int _init_value;
    };
}

#pragma once

#include <iostream>
#include <vector>
#include <pthread.h>

#include "Sem.hpp"

namespace RingBufferModule
{
    using namespace SemModule;
    template <typename T>
    class RingBuffer
    {
    public:
        RingBuffer(int cap): _ring(cap), _cap(cap), _p_step(0), _c_step(0), _datasem(0), _spacesem(cap)
        {    
        }

        // 这里我们为什么没有做判断 ?
        // 原因：信号量，本身就是表示资源数目的，只要成功， 就一定会有, 不需要判断!! -> sem
        // 之前 if 判断那里是把资源当作整体来申请，但是不会去整体使用(局部使用)
        // 而且我们也不知道使用情况，所有需要在内部做判断
        void Equeue(const T &in)
        {
            // 生产者
            _spacesem.P();
            _ring[_p_step] = in; // 生产完毕
            _p_step++;
            _p_step %= _cap;     // 维持唤醒特性
            _datasem.V();
        }
        void Pop(T *out)
        {
            // 消费者
            _datasem.P();
            *out = _ring[_c_step]; // 预订
            _c_step++;
            _c_step %= _cap;
            _spacesem.V();
        }

        ~RingBuffer()
        {
        }
    private:
        std::vector<T> _ring;   // 环， 临界资源
        int _cap;               // 总容量
        int _p_step;            // 生产者位置
        int _c_step;            // 消费位置

        Sem _datasem;         // 数据信号量
        Sem _spacesem;        // 空间信号量
    };
}

#include "RingBuffer.hpp"
#include <pthread.h>
#include <unistd.h>
#include <ctime>
#include <functional>

using namespace RingBufferModule;

void *Consumer(void *args)
{
    RingBuffer<int> *rb = static_cast<RingBuffer<int> *> (args);
    while(true)
    {
        sleep(1);
        // 1. 消费数据
        int data;
        rb->Pop(&data);

        // 2. 处理: 花时间
        std::cout << "消费了一个数据： " << data << std::endl;
    }
}

void *Productor(void *args)
{
    RingBuffer<int> *rb = static_cast<RingBuffer<int> *> (args);
    int data = 0;
    while(true)
    {
        // 1. 获取数据: 花时间
        //sleep(1);
        rb->Equeue(data);

        // 2. 生产数据
        std::cout << "生产了一个数据: " << data << std::endl;
        data++;
    }
}


int main()
{
    RingBuffer<int> *rb = new RingBuffer<int>(5); // 共享资源-> 临界对象

    // 单生产， 单消费
    pthread_t c1, p1;
    pthread_create(&c1, nullptr, Consumer, rb);
    pthread_create(&p1, nullptr, Productor, rb);

    pthread_join(c1, nullptr);
    pthread_join(p1, nullptr);
    
    delete rb;

    return 0;
}

int main()
{
    RingBuffer<int> *rb = new RingBuffer<int>(5);

    // 单生产， 单消费
    pthread_t c1, p1, c2, p2, c3;
    pthread_create(&c1, nullptr, Consumer, rb);
    pthread_create(&p1, nullptr, Productor, rb);
    pthread_create(&c2, nullptr, Consumer, rb);
    pthread_create(&p2, nullptr, Productor, rb);
    pthread_create(&c3, nullptr, Consumer, rb);

    pthread_join(c1, nullptr);
    pthread_join(p1, nullptr);
    pthread_join(c2, nullptr);
    pthread_join(p2, nullptr);
    pthread_join(c3, nullptr);
    
    delete rb;

    return 0;
}

#pragma once

#include <iostream>
#include <vector>
#include <pthread.h>

#include "Sem.hpp"
#include "Mutex.hpp"

namespace RingBufferModule
{
    using namespace SemModule;
    using namespace LockModule;

    template <typename T>
    class RingBuffer
    {
    public:
        RingBuffer(int cap): _ring(cap), _cap(cap), _p_step(0), _c_step(0), _datasem(0), _spacesem(cap)
        {
        }

        void Equeue(const T &in)
        {
            // 生产者
            _spacesem.P();
            {
                LockGuard lockguard(_p_lock);
                _ring[_p_step] = in; // 生产完毕
                _p_step++;
                _p_step %= _cap;     // 维持唤醒特性
            }
            _datasem.V();
        }
        void Pop(T *out)
        {
            // 消费者
            _datasem.P();
            {
                LockGuard lockguard(_c_lock);
                *out = _ring[_c_step]; // 预订
                _c_step++;
                _c_step %= _cap;
            }
            _spacesem.V();
        }

        ~RingBuffer()
        {
        }

    private:
        std::vector<T> _ring;   // 环， 临界资源
        int _cap;               // 总容量
        int _p_step;            // 生产者位置
        int _c_step;            // 消费位置

        Sem _datasem;         // 数据信号量
        Sem _spacesem;        // 空间信号量

        Mutex _p_lock;
        Mutex _c_lock;

    };
}