【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量

这篇具有很好参考价值的文章主要介绍了【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、生产者消费者模型

我们这里举一个例子,来解释生产者消费者模型,我们学生–消费者,供应商–生产者,超市–交易场所,我们买东西只需要关系售货架子上是否有商品即可,没有了商品,超市从供应商进行供货。供应商和供应商不能同时向一个货架进行供货,所以生产者之间是互斥的关系,非消费者和消费不能同时从同一个货架拿商品,所以消费者与消费者之间是互斥的关系,而消费者需要等生产者将商品放到货架之后才能拿取商品,所以生产者和消费者之间是互斥和同步的关系。

生产消费模型:

生产者和生产者之间:互斥关系

消费者和消费者之间:互斥关系

生产者和消费者之间:互斥&&同步

总结:“321”原则:

3种关系:生产者和生产者(互斥),消费者和消费者(互斥),生产者和消费者

互斥保证共享资源的安全性]同步)–产品(数据)

种角色:生产者线程,消费者线程

1个交易场所:(一段特定结构的缓冲区

只要我们想写生产消费模型,我们本质工作其实就是维护321原则!

挖掘特点:

1.生产线程和消费线程进行解耦

2支持生产和消费的一段时间的忙闲不均的问题

3.提高效率

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

生产者消费者模型优点

解耦

支持并发

支持忙闲不均

【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量,Linux系统编程,linux,生产者消费者模型,阻塞队列,环形队列,POSIX信号量,多线程

二、基于BlockingQueue的生产者消费者模型

BlockingQueue

在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于,当队列为空时,从队列获取元素的操作将会被阻塞,直到队列中被放入了元素;当队列满时,往队列里存放元素的操作也会被阻塞,直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的,线程在对阻塞队列进程操作时会被阻塞)

【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量,Linux系统编程,linux,生产者消费者模型,阻塞队列,环形队列,POSIX信号量,多线程

1.BlockQueue.hpp

#pragma once

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

using namespace std;
const int gnum = 5;

template <class T>
class BlockQueue
{
public:
    BlockQueue(const int& maxcap = gnum)
        : _maxcap(maxcap)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    void push(const T &in) // 输出型参数:*, // 输入输出型:&
    {
        pthread_mutex_lock(&_mutex);
        // 1. 判断
        // 细节2: 充当条件判断的语法必须是while,不能用if
        while (is_full())
        {
            // 细节1:pthread_cond_wait这个函数的第二个参数,必须是我们正在使用的互斥锁!
            // a. pthread_cond_wait: 该函数调用的时候,会以原子性的方式,将锁释放,并将自己挂起
            // b. pthread_cond_wait: 该函数在被唤醒返回的时候,会自动的重新获取你传入的锁
            pthread_cond_wait(&_pcond, &_mutex);
        }

        // 2. 走到这里一定是没有满
        _q.push(in);

        // 3. 绝对能保证,阻塞队列里面一定有数据
        // 细节3:pthread_cond_signal:这个函数,可以放在临界区内部,也可以放在外部
        
        pthread_cond_signal(&_ccond);
        pthread_mutex_unlock(&_mutex);
    }

    void pop(T *out)
    {
        pthread_mutex_lock(&_mutex);
        // 1. 判断
        while (is_empty())
        {
            pthread_cond_wait(&_ccond, &_mutex);
        }

        // 2. 走到这里我们能保证,一定不为空
        *out = _q.front();
        _q.pop();

        // 3. 绝对能保证,阻塞队列里面,至少有一个空的位置!
        pthread_cond_signal(&_pcond);
        pthread_mutex_unlock(&_mutex);
    }

    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

private:
    bool is_full()
    {
        return _q.size() == _maxcap;
    }

    bool is_empty()
    {
        return _q.empty();
    }

private:
    queue<T> _q;
    int _maxcap; // 队列中元素的上限
    pthread_mutex_t _mutex;
    pthread_cond_t _pcond; // 生产者对应的条件变量
    pthread_cond_t _ccond; // 消费者对应的条件变量
};

2.Task.hpp

#pragma once

#include <iostream>
#include <string>
#include <functional>

class CalTask
{
public:
    typedef std::function<int(int, int, char)> func_t;
    // using func_t = std::function<int(int, int, char)>;

public:
    CalTask()
    {
    }
    CalTask(int x, int y, char op, func_t func)
        : _x(x), _y(y), _op(op), _callback(func)
    {
    }

    std::string operator()()
    {
        int result = _callback(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = %d", _x, _op, _y, result);
        return buffer;
    }

    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }

private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};

const std::string oper = "+-*/%";

int calculate(int x, int y, char op)
{
    int result = 0;
    switch (op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
    {
        if (y == 0)
        {
            std::cerr << "div zero error" << std::endl;
            return -1;
        }
        else
            result = x / y;
    }
    break;
    case '%':
    {
        if (y == 0)
        {
            std::cerr << "mod zero error" << std::endl;
            return -1;
        }
        else
            result = x % y;
    }
    break;
    default:
        std::cerr << "请输入正确的操作符" << std::endl;
        break;
    }

    return result;
}

class SaveTask
{
public:
    using func_t = function<void(const std::string &)>;

public:
    SaveTask()
    {
    }
    SaveTask(const std::string &message, func_t func)
        : _message(message), _func(func)
    {
    }

    void operator()()
    {
        _func(_message);
    }

    ~SaveTask()
    {
    }

private:
    std::string _message;
    func_t _func;
};

void Save(const std::string &message)
{
    const std::string target = "./log.txt";
    FILE *fp = fopen(target.c_str(), "a+");
    if (fp == nullptr)
    {
        perror("fopen error");
        return;
    }
    fputs(message.c_str(), fp);
    fputs("\n", fp);

    fclose(fp);
}

3.main.cc

#include "BlockQueue.hpp"
#include "Task.hpp"

#include <ctime>
#include <unistd.h>
#include <sys/types.h>

// C:计算
// S: 存储
template <class C, class S>
class BlockQueues
{
public:
    BlockQueue<C> *_cbq;
    BlockQueue<S> *_sbq;
};

void *productor(void *args)
{
    BlockQueue<CalTask> *bq = static_cast<BlockQueues<CalTask, SaveTask> *>(args)->_cbq;

    while (true)
    {
        int x = rand() % 10 + 1;
        int y = rand() % 5;
        char op = oper[rand() % 5];

        CalTask t(x, y, op, calculate);
        bq->push(t);

        std::cout << "productor thread 生产计算任务: " << t.toTaskString() << std::endl;

        sleep(1);
    }

    return nullptr;
}

void *consumer(void *args)
{
    BlockQueue<CalTask> *bq = static_cast<BlockQueues<CalTask, SaveTask> *>(args)->_cbq;
    BlockQueue<SaveTask> *save_bq = static_cast<BlockQueues<CalTask, SaveTask> *>(args)->_sbq;

    while (true)
    {
        CalTask t;
        bq->pop(&t);
        std::string result = t();

        std::cout << "cal thread,完成计算任务: " << result << " ... done" << std::endl;

        SaveTask st(result, Save);
        save_bq->push(st);
        cout << "cal thread,推送存储任务完成..." << std::endl;

        sleep(1);
    }
    return nullptr;
}

void *saver(void *args)
{
    BlockQueue<SaveTask> *save_bq = static_cast<BlockQueues<CalTask, SaveTask> *>(args)->_sbq;

    while (true)
    {
        SaveTask st;
        save_bq->pop(&st);
        st();
        std::cout << "save thread,保存任务完成..." << std::endl;
        // sleep(1);
    }

    return nullptr;
}

int main()
{
    BlockQueues<CalTask, SaveTask> bqs;
    bqs._cbq = new BlockQueue<CalTask>();
    bqs._sbq = new BlockQueue<SaveTask>();

    pthread_t p, c, s;
    pthread_create(&p, nullptr, productor, &bqs);
    pthread_create(&c, nullptr, consumer, &bqs);
    pthread_create(&s, nullptr, saver, &bqs);

    pthread_join(p, nullptr);
    pthread_join(c, nullptr);
    pthread_join(s, nullptr);

    delete bqs._cbq;
    delete bqs._sbq;

    return 0;
}

你创建多线程生产和消费的意义是什么??2.生产消费模型高效在哪里??

可以在生产之前,和消费之后,让线程并行执行

生产者而言,向blockqueue里面放置任务

他的任务从哪里来的呢?它获取任务和构建任务要不要花时间?

消费者而言,从blockqueue里面拿取任务

对于消费者,难道他把任务从任务队列中拿出来就完了吗??消费者拿到任务之后,后续还有没有任务??

三、POSIX信号量

先发现我们之前写的代码的不足的地方

pthread_mutex_lock(&_mutex);
while (is_full())
{
    pthread_cond_wait(&_pcond, &_mutex);
}
_q.push(in);
pthread_cond_signal(&_ccond);
pthread_mutex_unlock(&_mutex);

1.一个线程,在操作临界资源的时候,必须临界资源是满足条件的!

2.可是,公共资源是否满足生产或者消费条件,我们无法、直接得知【我们不能事前得知【在没有访问之前,无法得知】】

3.只能先加锁,再检测,再操作,再解锁。因为你要检测,本质:也是在访问临界资源!

因为我们在操作临界资源的时候,有可能不就绪但是,我们无法提前得知,所以,只能先加锁,在检测,根据检测结果,决定下一步怎么走!

只要我们对资源进行整体加锁,就默认了,我们对这个资源整体使用。实际情况可能存在:.一份公共资源,但是允许同时访问不同的区域!程序员编码保证不同的线程可以并发访问公共资源的不同区域!

什么是信号量:

a.信号量本质是一把计数器。衡量临界资源中资源数量多少的计数器

b.只要拥有信号量,就在未来一定能够拥有临界资源的一部分,申请信号量的本质:对临界资源中特定小块资源的预订机制

线程要访问临界资源中的某一区域–申请信号量–所有人必须的先看到信号量–信号量本身必须是:公共资源

有可能,我们在访问真正的临界资源之前,我们其实就可以提前知道临界资源的使用情况! ! !

信号量只要申请成功,就一定有你的资源。只要申请失败,就说明条件不就绪,你只能等!!不需要在判断了!

计数器–递减or 递增sem_t sem = 10;

sem–;—申请资源—必须保证操作的原子性— P

sem++;—归还资源—必须保证操作的原子性----V

信号量核心操作:PV原语

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);

等待信号量

功能:等待信号量,会将信号量的值减1
int sem_wait(sem_t *sem); //P()

发布信号量

功能:发布信号量,表示资源使用完毕,可以归还资源了。将信号量值加1int sem_post(sem_t *sem);//V()

四、基于环形队列的生产消费模型

环形队列采用数组模拟,用模运算来模拟环状特性

【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量,Linux系统编程,linux,生产者消费者模型,阻塞队列,环形队列,POSIX信号量,多线程

环形结构起始状态和结束状态都是一样的,不好判断为空或者为满,所以可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置,作为满的状态

【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量,Linux系统编程,linux,生产者消费者模型,阻塞队列,环形队列,POSIX信号量,多线程

但是我们现在有信号量这个计数器,就很简单的进行多线程间的同步过程

生产和消费在什么情况下可能访问同一个位置:

1.空的时候

2.满的时候

3.其他情况,生产者和消费者,根本访问的就是不同的区域!

为了完成环形队列cp问题,我们要做的核心工作是什么

1.你不能超过我

2我不能把你套一个圈以上

3.我们两个什么时候,会站在一起?

信号量是用来衡量临界资源中资源数量的

1.对于生产者而言,看中什么?队列中的剩余空间—空间资源定义十个信号量

2.对于消费者而言,看中的是什么?放入队列中的数据! —数据资源定义一个信号量

生产者而言:

prodocter_sem: 0
// 申请成功,你就可以继续向下运行。
//申请失败,当前执行流,阻塞在申请处
P(producter_sem);
//从事生产活动--把数据放入到队列中
V(comsumer_sem);

消费者而言:

comsumer_sem:10
P(comsumer_sem);
//从事消费活动
v(producter_sem);_

未来,生产和消费的位置我们要想清楚:

1.其实就是队列中的下标、

2一定是两个下标

3.为空或者为满,下标相同文章来源地址https://www.toymoban.com/news/detail-768050.html

1.RingQueue.hpp

#pragma once

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

static const int gcap = 5;

template <class T>
class RingQueue
{
private:
    // 等待信号量,会将信号量的值减1
    void P(sem_t &sem)
    {
        int n = sem_wait(&sem);
        assert(n == 0);
        (void)n;
    }
    // 发布信号量,表示资源使用完毕,可以归还资源了。将信号量值加1。
    void V(sem_t &sem)
    {
        int n = sem_post(&sem);
        assert(n == 0);
        (void)n;
    }

public:
    RingQueue(const int &cap = gcap)
        : _queue(cap), _cap(cap)
    {
        int n = sem_init(&_spaceSem, 0, _cap);
        assert(n == 0);
        n = sem_init(&_dataSem, 0, 0);
        assert(n == 0);

        _productorStep = _consumerStep = 0;

        pthread_mutex_init(&_pmutex, nullptr);
        pthread_mutex_init(&_cmutex, nullptr);
    }

    // 生产者
    void push(const T &in)
    {
        P(_spaceSem);
        pthread_mutex_lock(&_pmutex);
        _queue[_productorStep++] = in;
        _productorStep %= _cap;
        pthread_mutex_unlock(&_pmutex);
        V(_dataSem);
    }

    // 消费者
    void pop(T *out)
    {
        P(_dataSem);
        pthread_mutex_lock(&_cmutex);
        *out = _queue[_consumerStep++];
        _consumerStep %= _cap;
        pthread_mutex_unlock(&_cmutex);
        V(_spaceSem);
    }
    ~RingQueue()
    {
        sem_destroy(&_spaceSem);
        sem_destroy(&_dataSem);

        pthread_mutex_destroy(&_pmutex);
        pthread_mutex_destroy(&_cmutex);
    }

private:
    std::vector<T> _queue;
    int _cap;
    sem_t _spaceSem; // 生产者 想生产,看中的是什么资源呢? 空间资源
    sem_t _dataSem;  // 消费者 想消费,看中的是什么资源呢? 数据资源
    int _productorStep;
    int _consumerStep;
    pthread_mutex_t _pmutex;
    pthread_mutex_t _cmutex;
};

2.Task.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstdio>
#include <functional>

class Task
{
    using func_t = std::function<int(int,int,char)>;
    // typedef std::function<int(int,int)> func_t;
public:
    Task()
    {}
    Task(int x, int y, char op, func_t func)
    :_x(x), _y(y), _op(op), _callback(func)
    {}
    std::string operator()()
    {
        int result = _callback(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = %d", _x, _op, _y, result);
        return buffer;
    }
    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }
private:
    int _x;
    int _y;
    char _op;
    func_t _callback;
};

const std::string oper = "+-*/%";

int mymath(int x, int y, char op)
{
    int result = 0;
    switch (op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
    {
        if (y == 0)
        {
            std::cerr << "div zero error!" << std::endl;
            result = -1;
        }
        else
            result = x / y;
    }
        break;
    case '%':
    {
        if (y == 0)
        {
            std::cerr << "mod zero error!" << std::endl;
            result = -1;
        }
        else
            result = x % y;
    }
        break;
    default:
        // do nothing
        break;
    }

    return result;
}

3.main.cc

#include "RingQueue.hpp"
#include "Task.hpp"
#include <pthread.h>
#include <ctime>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>

std::string SelfName()
{
    char name[128];
    snprintf(name, sizeof(name), "thread[0x%x]", pthread_self());
    return name;
}

void *ProductorRoutine(void *rq)
{
    // RingQueue<int> *ringqueue = static_cast<RingQueue<int> *>(rq);
    RingQueue<Task> *ringqueue = static_cast<RingQueue<Task> *>(rq);
    while (true)
    {
        // version1
        // int data = rand() % 10 + 1;
        // ringqueue->Push(data);
        // std::cout << "生产完成,生产的数据是:" << data << std::endl;

        // version2
        // 构建or获取任务 --- 这个是要花时间的!
        int x = rand() % 10;
        int y = rand() % 5;
        char op = oper[rand() % oper.size()];
        Task t(x, y, op, mymath);
        // 生产任务
        ringqueue->push(t);
        // 输出提示
        std::cout << SelfName() << ", 生产者派发了一个任务: " << t.toTaskString() << std::endl;

        // sleep(1);
    }
}

void *ConsumerRoutine(void *rq)
{
    // RingQueue<int> *ringqueue = static_cast<RingQueue<int> *>(rq);
    RingQueue<Task> *ringqueue = static_cast<RingQueue<Task> *>(rq);

    while (true)
    {
        // version1
        //  int data;
        //  ringqueue->Pop(&data);
        //  std::cout << "消费完成,消费的数据是:" << data << std::endl;
        //  sleep(1);

        // version2
        Task t;
        // 消费任务
        ringqueue->pop(&t);
        std::string result = t(); // 消费也是要花时间的!
        std::cout << SelfName() << ", 消费者消费了一个任务: " << result << std::endl;

        // sleep(1);
    }
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ pthread_self() ^ 0x71727374);
    // RingQueue<int> *rq = new RingQueue<int>();
    RingQueue<Task> *rq = new RingQueue<Task>();

    // 单生产,单消费,多生产,多消费 --> 只要保证,最终进入临界区的是一个生产,一个消费就行!
    // 多生产,多消费的意义??
    pthread_t p[4], c[8];
    for (int i = 0; i < 4; i++)
        pthread_create(p + i, nullptr, ProductorRoutine, rq);
    for (int i = 0; i < 8; i++)
        pthread_create(c + i, nullptr, ConsumerRoutine, rq);

    for (int i = 0; i < 4; i++)
        pthread_join(p[i], nullptr);
    for (int i = 0; i < 8; i++)
        pthread_join(c[i], nullptr);
    delete rq;
    return 0;
}

到了这里,关于【Linux】生产者消费者模型(阻塞队列与环形队列)和POSIX信号量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【linux】线程同步+基于BlockingQueue的生产者消费者模型

    喜欢的点赞,收藏,关注一下把! 在线程互斥写了一份抢票的代码,我们发现虽然加锁解决了抢到负数票的问题,但是一直都是一个线程在抢票,它错了吗,它没错但是不合理。那我们应该如何安全合理的抢票呢? 讲个小故事。 假设学校有一个VIP学霸自习室,这个自习室有

    2024年02月03日
    浏览(100)
  • 【Linux】生产者消费者模型代码实现和信号量

    一定要先理解生产者消费者模型的原理~ 文章目录 一、生产者消费者模型实现代码 二、信号量 1.基于环形队列的生产者消费者模型 总结 下面我们实现基于阻塞队列的生产消费模型: 在多线程编程中阻塞队列 (Blocking Queue) 是一种常用于实现生产者和消费者模型的数据结构。其

    2024年02月11日
    浏览(40)
  • 【Linux】基于环形队列的生产者消费者模型的实现

    文章目录 前言 一、基于环形队列的生产者消费者模型的实现 上一篇文章我们讲了信号量的几个接口和基于环形队列的生产者消费者模型,下面我们就快速来实现。 首先我们创建三个文件,分别是makefile,RingQueue.hpp,以及main.cc。我们先简单搭建一下环形队列的框架: 首先我们

    2024年02月11日
    浏览(45)
  • Linux之信号量 | 消费者生产者模型的循环队列

    目录 一、信号量 1、概念 2、信号量操作函数 二、基于环形队列的生产者消费者模型 1、模型分析 2、代码实现 1、单生产单消费的生产者消费者模型 2、多生产多消费的生产者消费者模型 引入:前面我们讲到了,对临界资源进行访问时,为了保证数据的一致性,我们需要对临

    2024年04月17日
    浏览(40)
  • 『Linux』第九讲:Linux多线程详解(四)_ 生产者消费者模型

    「前言」文章是关于Linux多线程方面的知识,上一篇是 Linux多线程详解(三),今天这篇是 Linux多线程详解(四),内容大致是生产消费者模型,讲解下面开始! 「归属专栏」Linux系统编程 「主页链接」个人主页 「笔者」枫叶先生(fy) 「枫叶先生有点文青病」「每篇一句」

    2024年02月07日
    浏览(45)
  • Linux之【多线程】生产者与消费者模型&BlockQueue(阻塞队列)

    举个例子:学生要买东西,一般情况下都会直接联系厂商,因为买的商品不多,对于供货商来说交易成本太高,所以有了交易场所超市这个媒介的存在。目的就是为了集中需求,分发产品。 消费者与生产者之间通过了超市进行交易。当生产者不需要的时候,厂商可以继续生产

    2024年02月02日
    浏览(46)
  • 《Linux从练气到飞升》No.29 生产者消费者模型

    🕺作者: 主页 我的专栏 C语言从0到1 探秘C++ 数据结构从0到1 探秘Linux 菜鸟刷题集 😘欢迎关注:👍点赞🙌收藏✍️留言 🏇 码字不易,你的👍点赞🙌收藏❤️关注对我真的很重要,有问题可在评论区提出,感谢阅读!!!

    2024年02月05日
    浏览(42)
  • 【Linux】线程同步 -- 条件变量 | 生产者消费者模型 | 自旋锁 |读写锁

    举一个例子: 学生去超市消费的时候,与厂家生产的时候,两者互不相冲突。 生产的过程与消费的过程 – 解耦 临时的保存产品的场所(超时) – 缓冲区 模型总结“321”原则: 3种关系:生产者和生产者(互斥),消费者和消费者(互斥),生产者和消费者(互斥[保证共享资

    2024年02月14日
    浏览(37)
  • 线程池-手写线程池Linux C简单版本(生产者-消费者模型)

    本线程池采用C语言实现 线程池的场景: 当某些任务特别耗时(例如大量的IO读写操作),严重影响线程其他的任务的执行,可以使用线程池 线程池的一般特点: 线程池通常是一个生产者-消费者模型 生产者线程用于发布任务,任务通常保存在任务队列中 线程池作为消费者,

    2024年02月14日
    浏览(48)
  • 【Linux】POSIX信号量 | 基于环形队列的生产者消费者模型

    ​🌠 作者:@阿亮joy. 🎆 专栏: 《学会Linux》 🎇 座右铭:每个优秀的人都有一段沉默的时光,那段时光是付出了很多努力却得不到结果的日子,我们把它叫做扎根 POSIX 信号量和 SystemV 信号量作用相同,都是用于同步操作,达到无冲突的访问共享资源目的。 但 POSIX 可以用于

    2023年04月08日
    浏览(64)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包