从信号量开始的里牛渴死生活

最新推荐文章于 2024-11-04 12:30:03 发布

贩卖纯净水.

最新推荐文章于 2024-11-04 12:30:03 发布

阅读量1k

点赞数 25

分类专栏： Linux 文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/chestnut_orenge/article/details/142550939

版权

Linux 专栏收录该内容

35 篇文章 2 订阅

订阅专栏

讲讲信号量

POSIX信号量

这个曾经在进程间通信提过一嘴但是没怎么细说，POSIX信号量和SystemV信号量都可用于同步达到无冲突的访问共享资源的目的，POSIX还可以用于线程间同步

初始化

#include <semaphore.h> 
int sem_init(sem_t *sem, int pshared, unsigned int value);

参数： 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

环形队列

环形队列也是队列，也要遵守先进先出，哎哟但是我好像就这个没学啊我去

今天晚些时候学吧

逻辑是环状的，但是物理上是线性的，是通过取模运算模拟出来的

当环形队列为空或者为满的时候，head == end

我们需要一个计数器或者牺牲一个空位置区分空和满

我们如今的问题是多线程如何在环形队列中进行生产和消费

那么多线程如何在环形队列中生产和消费？

队列为空的时候让谁先访问呢？

肯定是让生产者先生产啊

队列为满的时候让谁访问？

肯定是让消费者来消费啊

在局部内访问资源有顺序性

大部分情况下这东西

不怎么出现

这样生产和消费会同时进行

我们的结论：

我们不能让生产者把消费者套一个圈

用信号量就能做到勒

消费者关心的资源是什么捏？

数据资源

生产者关心的什么资源？

空间

二者关心的东西不一样，相加为N

我们可以定义这两个东西，一个是sem_t data_sem=0（开始的时候）

第二个我们叫空间信号量，是sem_t space_sem=N

要有生产者和消费者

写接口，这是RunQueue.hpp:

#pragma once

#include<iostream>
#include<vector>
#include<string>
#include<semaphore.h>

template<typename T>
class RingQueue
{
private:
    void P(sem_t &s)
    {
        sem_wait(&s);
    }
    void V(sem_t &s)
    {
        sem_post(&s);
    }
public:
    RingQueue(int max_cap)
    :_max_cpp(max_cap),_ringqueue(max_cap),_c_step(0),_p_step(0)
    {
        sem_init(&_data_sem,0,0);
        sem_init(&_space_sem,0,max_cap);
    }
    void Push(const T &in)      //生产者
    {
        P(_space_sem);
        _ringqueue[_p_step]=in;
        _p_step++;
        _p_step%=_max_cpp;  //因为是环形队列
        V(_data_sem);    //完成生产要释放资源
    }
    void Pop(T* out)            //消费者
    {
        P(_data_sem);
        *out = _ringqueue[_c_step];
        _c_step++;
        _c_step%=_max_cpp;
        V(_space_sem);
    }
    ~RingQueue()
    {
        sem_destroy(&_data_sem);
        sem_destroy(&_space_sem);
    }
private:
    std::vector<T> _ringqueue;
    int _max_cpp;

    int _c_step;
    int _p_step;

    sem_t _data_sem;    //消费者关心
    sem_t _space_sem;   //生产者关心
};

用了一些手段

这是Main.cc：

#pragma once

#include"RunQueue.hpp"
#include<iostream>
#include<unistd.h>
#include<string>
#include<pthread.h>

void *Consumer(void* args)
{
    RingQueue<int> *rq = static_cast<RingQueue<int>*>(args);
    while (true)
    {
        sleep(1);
        int data = 0;
        //消费
        rq->Pop(&data);
        //处理数据
        std::cout << "Consumer -> " << data << std::endl;
    }
}

void* Productor(void* args)
{
    RingQueue<int> *rq = static_cast<RingQueue<int>*>(args);
    while (true)
    {
        sleep(1);
        //构造数据
        int data = rand() % 10 + 1;
        //生产
        rq->Push(data);
        std::cout << "Productor -> " << data << std::endl;
    }
}

int main()
{
    srand(time(nullptr)^getgid());
    RingQueue<int> *rq = new RingQueue<int>(5);

    pthread_t c,p;
    pthread_create(&c,nullptr,Consumer,rq);
    pthread_create(&p,nullptr,Productor,rq);

    pthread_join(c,nullptr);
    pthread_join(p,nullptr);
    return 0;
}

环形队列里也可以存放任务捏

Main.cc:

#pragma once

#include"RunQueue.hpp"
#include"Task.hpp"
#include<iostream>
#include<unistd.h>
#include<string>
#include<pthread.h>

void *Consumer(void* args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task>*>(args);
    while (true)
    {
        sleep(1);
        Task t;
        //消费
        rq->Pop(&t);
        //处理数据
        t();
        std::cout << "Consumer -> " << t.result() << std::endl;
    }
}

void* Productor(void* args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task>*>(args);
    while (true)
    {
        sleep(1);
        //构造数据
        int x = rand() % 10 + 1;
        int y = rand()%10 + 1;
        Task t(x,y);
        //生产
        rq->Push(t);
        std::cout << "Productor -> " << t.debug() << std::endl;
    }
}

int main()
{
    srand(time(nullptr)^getgid());
    RingQueue<Task> *rq = new RingQueue<Task>(5);

    pthread_t c,p;
    pthread_create(&c,nullptr,Consumer,rq);
    pthread_create(&p,nullptr,Productor,rq);

    pthread_join(c,nullptr);
    pthread_join(p,nullptr);
    return 0;
}

Task.hpp:

#pragma once

#include <iostream>
#include <string>

class Task 
{
public:
    Task() : x(0), y(0) 
    {}
    Task(int a, int b) : x(a), y(b) 
    {}

    // 执行任务，计算结果
    void operator()() 
    {
        result_value = x + y; // 示例操作：计算 x 和 y 的和
    }

    // 返回结果
    int result() const 
    {
        return result_value;
    }

    // 调试输出
    std::string debug() const 
    {
        return "Task: x = " + std::to_string(x) + ", y = " + std::to_string(y);
    }

private:
    int x; // 第一个参数
    int y; // 第二个参数
    int result_value; // 计算结果
};

这是单生产单消费的情况，那么多生产多消费的情况应该怎么改呢？

有个问题，要不要加锁？

我们要维护生产者和消费者之间的互斥关系，所以需要加锁，多个生产者进来了生产者的下标位置只有一个，于是他们的下标位置就变成了临界资源，那么问题来了，要加几把锁？

要加两把锁

有个问题，加锁这件事情到底是在申请信号量之前还是之后捏？

答案已经很明晰了，，，

肯定是在之后捏

你这么想，信号量相当于电影票，肯定是人手先一张票之后再排队比较好啊，

这样效率比较高捏

#pragma once

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

template<typename T>
class RingQueue
{
private:
    void P(sem_t &s)
    {
        sem_wait(&s);
    }
    void V(sem_t &s)
    {
        sem_post(&s);
    }
public:
    RingQueue(int max_cap)
    :_max_cpp(max_cap),_ringqueue(max_cap),_c_step(0),_p_step(0)
    {
        sem_init(&_data_sem,0,0);
        sem_init(&_space_sem,0,max_cap);

        pthread_mutex_init(&_c_mutex,nullptr);
        pthread_mutex_init(&_p_mutex,nullptr);
    }
    void Push(const T &in)      //生产者
    {
        P(_space_sem);
        pthread_mutex_lock(&_p_mutex);          //加锁
        _ringqueue[_p_step]=in;
        _p_step++;
        _p_step%=_max_cpp;      //因为是环形队列
        V(_data_sem);           //完成生产要释放资源
        pthread_mutex_unlock(&_p_mutex);    //解锁
    }
    void Pop(T* out)            //消费者
    {
        P(_data_sem);
        pthread_mutex_lock(&_c_mutex);          //加锁
        *out = _ringqueue[_c_step];
        _c_step++;
        _c_step%=_max_cpp;
        V(_space_sem);
        pthread_mutex_unlock(&_c_mutex);        //解锁
    }
    ~RingQueue()
    {
        sem_destroy(&_data_sem);
        sem_destroy(&_space_sem);

        pthread_mutex_destroy(&_c_mutex);
        pthread_mutex_destroy(&_p_mutex);
    }
private:
    std::vector<T> _ringqueue;
    int _max_cpp;

    int _c_step;
    int _p_step;

    sem_t _data_sem;        //消费者关心
    sem_t _space_sem;       //生产者关心

    pthread_mutex_t _c_mutex;
    pthread_mutex_t _p_mutex;
};

听着荷叶饭，我要开始升华了

信号量对资源进行使用为什么不判断一下条件是否满足呢？

因为信号量本身就是判断条件

信号量：是一个计数器，是资源的预定机制，在外部可以不判断资源是否满足，就可以知道内部资源的情况

这种就是二元信号量，二元信号量等同于互斥锁

多线程让我们能在处理数据和构造数据的过程中并发性高（这俩耗时比较长捏）

加几把锁啊好难啊我不想写了，，，