【Linux】生产者消费者模型 - 详解

多线程练习:生产者与消费者 /** * @author looper * @ **/ public class ProductorTest { public static void main(String[] args) { Clerk clerk = new Clerk(); //我要调用start 但是问题是,是属于tread下的方法,我要用子类来调用,所以 Productor productor = new Productor(clerk);//以为thrad(有参. 阅读详情

目录

一.生产者消费者模型概念

1.为何要使用生产者消费者模型

2.生产者消费者之间的关系

3.生产者消费者模型的优点

二.基于阻塞队列的生产消费模型

1.在阻塞队列中的三种关系

2.BlockingQueue.hpp - 阻塞队列类

3.LockGurad.hpp - RAII互斥锁类

4.Task.hpp - 在阻塞队列中生产/消费的任务类

5.CPTest.cc - 测试

三.基于环形队列的生产消费模型 

1.在环形队列中的三种关系

2.环形队列vs阻塞队列

3.CircularQueue.hpp - 环形队列类

4.LockGuard.hpp - RAII互斥锁类

5.Task.cpp - 任务类

6.CPTest.cc - 测试

四. 写在最后

1.关于条件变量的伪唤醒问题

2.关于信号量和锁的先后顺序问题 


一.生产者消费者模型概念

1.为何要使用生产者消费者模型

生产者消费者模式就是通过一个"容器"来解决生产者与消费者之间的强耦合问题, 生产者和消费者彼此之间不直接通讯, 而是通过特定"容器"来进行通讯, 所以生产者生产完数据之后不需要等待消费者处理, 直接扔给"容器", 消费者不直接找生产者索要数据, 而是从"容器"中拿数据, "容器"其实就是由特定的数据结构编写的缓冲区, 平衡了生产者和消费者的处理能力, 通过生产消费之间的"容器"达到解耦的目的

2.生产者消费者之间的关系

一个场所, 也就是上述"容器"

二个角色, 生产者与消费者

三种关系

        生产者 - 生产者: 互斥关系

        消费者 - 消费者: 互斥关系

        生产者 - 消费者: 互斥关系, 同步关系

生产者消费者模型分为两种

1.单生产单消费

2.多生产多消费

3.生产者消费者模型的优点

1.将生产者消费者的强耦合关系解耦

2.支持并发

二.基于阻塞队列的生产消费模型

1.在阻塞队列中的三种关系

生产者与生产者之间互斥

消费者与消费者之间互斥

生产者与消费者之间既互斥又同步

同步关系使用条件变量

2.BlockingQueue.hpp - 阻塞队列类

#pragma once

#include <iostream>
#include <queue>
#include "LockGurad.hpp"

template <class T>
class BlockingQueue
{
public:
    static BlockingQueue<T> *GetInst()
    {
        return &_sInst;
    }

public:
    void push(const T& in)
    {
        LockGurad lock(&_mutex); // RAII锁
        // 如果阻塞队列满了就阻塞
        while(isFull())
        {
            pthread_cond_wait(&_isFullCond, &_mutex); // 已满, 阻塞
        }
        _bq.push(in);
        pthread_cond_signal(&_isEmptyCond); // 已经添加了一个, 唤醒已空条件阻塞
    }

    void pop(T* out)
    {
        LockGurad lock(&_mutex); // RAII锁
        // 如果阻塞队列空了就阻塞
        while(isEmpty())
        {
            pthread_cond_wait(&_isEmptyCond, &_mutex); // 已空, 阻塞
        }
        *out = _bq.front();
        _bq.pop();
        pthread_cond_signal(&_isFullCond); // 已经取走了一个, 唤醒已满条件阻塞
    }

    ~BlockingQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_isFullCond);
        pthread_cond_destroy(&_isEmptyCond);
    }

private:
    bool isFull() // 判满
    {
        return _bq.size() == _capacity;
    }

    bool isEmpty() // 判空
    {
        return _bq.size() == 0;
    }

private:
    std::queue<T> _bq;          // 阻塞队列
    size_t _capacity;           // 阻塞队列最大容量
    pthread_mutex_t _mutex;      // 保护阻塞队列的锁
    pthread_cond_t _isFullCond;  // 判断是否为满
    pthread_cond_t _isEmptyCond; // 判断是否为空

private:
    // 单例模式
    BlockingQueue(size_t capacity = 5) : _capacity(capacity)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_isFullCond, nullptr);
        pthread_cond_init(&_isEmptyCond, nullptr);
    }
    BlockingQueue(const BlockingQueue<T> &copy) = delete;
    BlockingQueue<T> &operator=(const BlockingQueue<T> &copy) = delete;

    static BlockingQueue<T> _sInst;
};

template <class T>
BlockingQueue<T> BlockingQueue<T>::_sInst;

3.LockGurad.hpp - RAII互斥锁类

#pragma once

#include <pthread.h>

class LockGurad
{
public:
    LockGurad(pthread_mutex_t* mutex):_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }

    ~LockGurad()
    {
        pthread_mutex_unlock(_mutex);
    }

private:
    pthread_mutex_t* _mutex;
};

4.Task.hpp - 在阻塞队列中生产/消费的任务类

#pragma once

typedef int(* func_t)(int, int);

struct Task
{
    Task(){};
    Task(int x, int y, func_t func):_x(x),_y(y),_func(func)
    {}

    int operator()()
    {
        return _func(_x, _y);
    }

    int _x;
    int _y;

    func_t _func;
};

5.CPTest.cc - 测试

#include "BlockingQueue.hpp"
#include "Task.hpp"
#include "time.h"
#include "stdlib.h"
#include "sys/types.h"
#include "unistd.h"

int myAdd(int x, int y)
{
    return x + y;
}

void *Consumer(void *args)
{
    BlockingQueue<Task> *bqsInst = (BlockingQueue<Task> *)args;

    while (1)
    {
        // 消费任务
        Task t;
        bqsInst->pop(&t);

        std::cout << pthread_self() << " consumer: " << t._x << "+" << t._y << "=" << t() << std::endl;
        sleep(1);
    }

    return nullptr;
}

void *Provider(void *args)
{
    BlockingQueue<Task> *bqsInst = (BlockingQueue<Task> *)args;

    while (1)
    {
        // 制作任务
        int x = rand() % 100 + 1;
        int y = rand() % 100 + 1;
        Task t(x, y, myAdd);

        // 添加任务
        bqsInst->push(t);

        std::cout << pthread_self() << " productor: " << t._x << "+" << t._y << "=?" << std::endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123);

    // 获取单例指针
    BlockingQueue<Task> *bqsInst = BlockingQueue<Task>::GetInst();

    // 单生产单消费
    //pthread_t c, p;
    //pthread_create(&c, nullptr, Consumer, bqsInst);
    //pthread_create(&p, nullptr, Provider, bqsInst);

    // 多生产多消费
    pthread_t c[2], p[3];
    pthread_create(c, nullptr, Consumer, bqsInst);
    pthread_create(c + 1, nullptr, Consumer, bqsInst); 

    pthread_create(p, nullptr, Provider, bqsInst);
    pthread_create(p + 1, nullptr, Provider, bqsInst);
    pthread_create(p + 2, nullptr, Provider, bqsInst);

    pthread_join(c[0], nullptr);
    pthread_join(c[1], nullptr);
    
    pthread_join(p[0], nullptr);
    pthread_join(p[1], nullptr);
    pthread_join(p[2], nullptr);

    return 0;
}

三.基于环形队列的生产消费模型 

数据结构: 环形队列, 传送入口: http://t.csdn.cn/p1OXv

1.在环形队列中的三种关系

生产者与生产者之间互斥

消费者与消费者之间互斥

生产者与消费者之间同步

同步关系使用信号量

生产消费不需要互斥, 即分别用两把锁

2.环形队列vs阻塞队列

环形队列对比阻塞队列的优势: 生产与消费可以同时进行, 这是因为环形数据结构的特性, 以及信号量sem共同支持的

为什么?

对于阻塞队列而言

当阻塞队列中还存在有数据时, 生产者与消费者必然不会访问到同一个数据, 但是当队列为空, 如果不将生产与消费互斥的话, 就很可能在生产的同时又在消费, 消费的可能是正在生产中的数据, 就可能发生问题

对于环形队列而言

生产者与消费者的下标, 只有在环形队列满或空时指向同一位置, 通过信号量进行同步之后, 不可能会发生同时在同一位置生产消费的情况

生产消费指向同一位置, 只有两种情况

1.环形队列为满, 此时该位置是还存有未消费的数据, 没有多余的生产信号量, 该位置只可能存在消费行为

2.环形队列为空, 此时该位置不存有任何数据, 没有多余的消费信号量, 该位置只可能存在生产行为

3.CircularQueue.hpp - 环形队列类

#include <vector>
#include <semaphore.h>
#include "LockGurad.hpp"

template <class T>
class CircularQueue
{
public:
    CircularQueue(size_t capacity) : _capacity(capacity), _cStep(0), _pStep(0)
    {
        _v.resize(capacity);

        sem_init(&_spaceSem, 0, capacity);
        sem_init(&_dataSem, 0, 0);

        pthread_mutex_init(&_cMtx, nullptr);
        pthread_mutex_init(&_pMtx, nullptr);
    }

    void push(const T &in)
    {
        // 这里把信号量加在锁前面, 进一步提高效率, 原理类似于买票看电影, 提前买票在排队检票效率更高
        sem_wait(&_spaceSem);
        {
            LockGurad lock(&_pMtx); // RAII加锁风格
            _v[_pStep++] = in;
            _pStep %= _capacity;
        }
        sem_post(&_dataSem);
    }

    void pop(T *out)
    {
        sem_wait(&_dataSem);
        {
            LockGurad lock(&_cMtx);
            *out = _v[_cStep++];
            _cStep %= _capacity;
        }
        sem_post(&_spaceSem);
    }

    ~CircularQueue()
    {
        sem_destroy(&_spaceSem);
        sem_destroy(&_dataSem);

        pthread_mutex_destroy(&_cMtx);
        pthread_mutex_destroy(&_pMtx);
    }

private:
    std::vector<T> _v;     // 环形队列
    size_t _capacity; // 最大容量

    int _cStep; // 消费下标
    int _pStep; // 生产下标

    sem_t _spaceSem; // 空间资源信号量
    sem_t _dataSem;  // 数据资源信号量

    pthread_mutex_t _cMtx; // 生产锁
    pthread_mutex_t _pMtx; // 消费锁
};

4.LockGuard.hpp - RAII互斥锁类

#pragma once

#include <pthread.h>

class LockGurad
{
public:
    LockGurad(pthread_mutex_t* mutex):_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }

    ~LockGurad()
    {
        pthread_mutex_unlock(_mutex);
    }

private:
    pthread_mutex_t* _mutex;
};

5.Task.cpp - 任务类

#pragma once

typedef int(* func_t)(int, int);

struct Task
{
    Task(){};
    Task(int x, int y, func_t func):_x(x),_y(y),_func(func)
    {}

    int operator()()
    {
        return _func(_x, _y);
    }

    int _x;
    int _y;

    func_t _func;
};

6.CPTest.cc - 测试

#include <iostream>
#include "CircularQueue.hpp"
#include "Task.hpp"
#include <time.h>
#include <unistd.h>
#include <stdlib.h>

int myAdd(int x, int y)
{
    return x + y;
}

void* Consumer(void* args)
{
    CircularQueue<Task>* cq = (CircularQueue<Task>*)args;

    while(1)
    {
        // 消费任务
        Task t;
        cq->pop(&t);

        std::cout << "消费: " << t._x << "+" << t._y << "=" << t() << std::endl;
    }
}

void* Provider(void* args)
{
    CircularQueue<Task>* cq = (CircularQueue<Task>*)args;

    while(1)
    {
        // 制作任务
        int x = rand() % 50 + 1;
        int y = rand() % 50 + 1;
        Task t(x, y, myAdd);

        // 添加任务
        cq->push(t);

        std::cout << "生产: " << t._x << "+" << t._y << "=?" << std::endl;
        sleep(1);
    }
}

int main()
{
    srand((unsigned int)time(nullptr) ^ 0x123);

    CircularQueue<Task>* cq = new CircularQueue<Task>(5);

    pthread_t c[2], p[3];
    pthread_create(c, nullptr, Consumer, cq);
    pthread_create(c+1, nullptr, Consumer, cq);

    pthread_create(p, nullptr, Provider, cq);
    pthread_create(p+1, nullptr, Provider, cq);
    pthread_create(p+2, nullptr, Provider, cq);

    pthread_join(c[0], nullptr);
    pthread_join(c[1], nullptr);

    pthread_join(p[0], nullptr);
    pthread_join(p[1], nullptr);
    pthread_join(p[2], nullptr);

    return 0;
}

四. 写在最后

1.关于条件变量的伪唤醒问题

为什么不用if, 而使用while, 原因就是如果此时只有1个资源, 而刚刚有很多个线程在挂起等待, 为了这1个资源全部被唤醒了, 那么就一定只有一个线程真正的拿到资源, 其他线程都是伪唤醒, 避免这种问题的方法就是用while判断, 当线程被唤醒时再循环判断一次, 如果为假就会跳出循环, 如果为真说明是伪唤醒, 则继续挂起等待

2.关于信号量和锁的先后顺序问题 

值得一提的是, 环形队列中生产者消费者的同步关系由信号量来实现, 并且生产者与消费者之间没有互斥关系, 那么生产者与消费者分别使用两把锁维护其各自的互斥关系, 那么有一个值得思考的问题就是信号量和锁谁在前谁在后问题

 答案是: 信号量先申请比较好. 信号量确实访问了临界资源, 但其内部实现也是原子性的, 而且信号量类似于预定机制, 只是提前把资源预定下来, 想要访问资源, 只需要等待取走锁资源即可

Linux C++共享内存实现:POSIX API与生产者消费者模型详解 进程间通信(IPC)是操作系统与分布式系统设计的核心概念之一,旨在解决不同执行单元间的数据交换与协同问题。其原理在于操作系统内核提供的多种机制,如管道、消息队列、套接字以及共享内存等,允许进程跨越隔离的地址空间进行交互。从技术价值看,高效的IPC机制能显著提升系统整体性能与模块化程度,是构建高性能服务器、微服务架构及实时系统的基石。在众多应用场景中,如数据库连接池、缓存服务、实时数据处理流水线等,对低延迟、高吞吐的数据交换有着迫切需求。本文聚焦于其中性能最优的共享内存技术,深入探讨其在Linux环境下,如何 阅读详情

相关推荐

生产者消费者问题(信号量)(linux)实现代码

参考教材中的生产者消费者算法,创建5个进程,其中两个进程为生产者进程,3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母,另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果,仿照的实例程序,分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。

【Linux】生产者消费者模型

生产者消费者模型

qq_53893431的博客 1551

进程线程之间的同步生产者消费者信号量读者写者写者优先

1。生产者消费者问题(信号量+mutex) 参考教材中的生产者消费者算法,创建5个进程,其中两个进程为生产者进程,3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母,另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果,仿照阅读材料中的实例程序,分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。 可选的实验:在上面实验的基础上实现部分消费者有选择地消费某些产品。例如一个消费者只消费小写字符,一个消费者只消费大写字母,而另一个消费者则无选择地消费任何产品。消费者要消费的产品没有时,消费者进程被阻塞。注意缓冲的管理。 2。用信号量和mutex方式实现睡觉的理发师问题 3。读者写者问题 教材和相关的阅读材料中对读者写者问题算法均有描述,但这个算法在不断地有读者流的情况下,写者会被阻塞。编写一个写者优先解决读者写者问题的程序,其中读者和写者均是多个进程,用信号量作为同步互斥机制。

【Linux】生产者 消费者模型

针对上述情况,将if判断改为while循环,每一次被唤醒都要被检测,只有当队列真的是不满的情况,才会进行push。发生休眠实际上就是线程切换,当线程从休眠状态被唤醒时,因为是从临界区被切走的,所以继续从临界区内部执行。供货商可以集中生产的一大批的商品 放到超市中,让消费者随时随地来买,供货商就不生产了。如:若超市火腿肠满了,就应该让消费者先消费,若超市没有火腿肠了,就应该让生产者先生产。若队列中没有数据存在,则不该让消费者消费,若队列中数据满了,不该让生产者进行生产。

qq_62939852的博客 1038

操作系统实验——进程的同步与互斥(读者写者问题)

以生产者消费者模型为基础,在Windows环境下创建一个控制台进程,在该进程中创建读者写者线程模拟生产者和消费者。写者线程写入数据,然后将数据放置在一个空缓冲区中供读者线程读取。读者线程从缓冲区中获得数据,然后释放缓冲区。当写者线程写入数据时,如果没有空缓冲区可用,那么写者线程必须等待读者线程释放出一个空缓冲区。当读者线程读取数据时,如果没有满的缓冲区,那么读入线程将被阻塞,直到新的数据被写进去。

S7-200 Smart 控制运动轴(脉冲电机/伺服)教程

S7-200 Smart 控制运动轴(脉冲电机/伺服) 结合本人刚接触触摸屏时候的踩坑经验,编写S7-200 Smart 控制运动轴(脉冲电机/伺服)的详细流程,给刚接触PLC的朋友提供一些经验指导。 本文详细介绍了S7-200 Smart 控制脉冲步进/伺服电机流程,包含接线方法及梯形图。希望对初学者有所帮助

xjbsw0的博客 5万+

『Linux』第九讲:Linux多线程详解(四)_ 生产者消费者模型

生产者消费者模型详解

枫叶先生的博客 2059

【强化学习的数学原理-赵世钰】课程笔记(一)基本概念

在B站上学习强化学习的课程笔记,笔记非常详细清晰,会持续更新

qq_64671439的博客 1万+

【linux线程(三)】生产者消费者模型详解(多版本)

本篇文章着重讲解了生产者消费者模型的概念以及如何实现基于队列和环形队列的生产者消费者模型,并且拓展讲解了信号量相关的内容,内附代码和图文讲解,看完就能学会

杭电码农-NEO的博客 1967

2023东华大学机试OJ进阶版1-81题

先排序。每次找两个最小的数,把其中一个置为两数之和,并累加这个和值,另一个数置为-1,然后再排序,重复操作,直到只剩下一个数。105。

m0_49263811的博客 2798

【系统移植】 移植主线U-Boot(v2024.01-rc3)到RK3399

[系统移植] 移植主线U-Boot(v2024.01-rc3)到RK3399

Systemcall名屋 1008

Linux C多线程编程:生产者消费者模型原理与实现详解

在并发编程中,线程同步是确保多线程程序正确性的核心挑战。其基本原理是通过互斥锁和条件变量等同步原语,协调多个线程对共享资源的访问,防止数据竞争和竞态条件。这项技术的核心价值在于解耦生产与消费速率,提升系统吞吐量和资源利用率,广泛应用于网络服务器、数据流处理、任务队列等高性能场景。本文聚焦于Linux C环境下的经典实现,深入剖析了互斥锁与条件变量的协同工作机制,并提供了可复用的环形缓冲区代码示例,帮助开发者掌握这一并发编程的基石模型。

weixin_34067102的博客 406

【用unity实现100个游戏之1】制作类元气骑士、挺进地牢——俯视角射击游戏多种射击效果(一)(附源码)

俯视角射击游戏)是一类以俯视视角进行游戏展示的射击游戏。在这种游戏中,玩家控制着一个角色或载具,从俯视的角度上方观察游戏世界,并与敌人进行战斗。这种视角使玩家能够有更好的全局观察和策略性,同时也强调快速反应和精确射击。视角:俯视角度可以是固定的,也可以随着玩家角色的移动而变化,但都允许玩家以全局视角观察整个战场,有利于制定战略和规划行动。射击:玩家通常需要使用各种武器来与敌人进行战斗,包括枪械、爆炸物等。射击动作依赖于玩家的反应速度和准确性。

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 7837

【linux线程(3)】生产者消费者模型详解

学习进程和线程也很久了,它们具体能解决什么问题?有什么实际的运用?本章重点:本篇文章着重讲解基于多线程下的生产者消费者模型的概念以及实现.不仅如此,文章还会拓展基于使用信号量实现的环形队列版的生产者消费者模型生产者消费者模型是我们学习线程中的一个很重要的模型,它的思想有助于帮我们解决后续的难题,并且校招时,有可能会让手撕一个生产者消费者模型,所以同学要学扎实了.

2301_77900444的博客 907

模型实战(16)之StrongSort (OSNET)配合YOLOv5、v7、v8 实现多目标跟踪详解

StrongSort (OSNET)配合YOLOv5、v7、v8 实现多目标跟踪详解

yohnyang的博客 1771

【ArcGIS微课1000例】0066:图像融合(全色+多光谱)操作案例教程

图像融合是指将不同类型传感器的影像进行融合,既能使图向具有较高的空间分辨率,又具有多光谱的特性。除了遥感软件如Erdas能进行图像融合,ArcGIS软件也可以进行图像融合等图像增强操作。

智慧空间实验室 3083

Linux下生产者消费者模型详解与示例介绍

在并发编程中,生产者消费者模型是一种经典的解决方案,用于解决生产者和消费者之间数据同步与通信的问题。Linux提供了多种机制来实现这种模型,如线程、进程间通信(IPC)等。5i <= 10;通过本文的介绍,你学习了在Linux环境下实现生产者消费者模型的基本概念和示例代码。生产者消费者模型在并发编程中是一个重要且常用的模型,对于理解多线程、进程间通信等概念具有重要意义。

深耕嵌入式领用多年, 致力于分享嵌入式领域技术! 418

AUTOSAR EcuM模块介绍

AUTOSAR EcuM概述 AUTOSAR EcuM全称是Autosar ECU State Manager,位于Autosar BSW中System Service模块中,是一个独立于硬件的模块。 其主要作用是管理ECU上下电启动的状态,具体为: 初始化启动操作系统所需要的BSW(Basic Software)模块 为睡眠阶段和随后的唤醒完成微控制器的配置准备 管理ECU上的所有唤醒事件(EcuM通过唤醒验证协议验证已发生的唤醒,区分真实的唤醒事件,防止误唤醒) EcuM支持的特性列表 EcuM具有

酒无忧的博客 3001

Linux 多线程:生产者消费者模型、阻塞队列与条件变量详解

生产者消费者模型是一种通过缓冲区(如阻塞队列)解耦生产者和消费者的并发设计模式。生产者将数据放入队列后无需等待消费者处理,消费者直接从队列获取数据,从而平衡两者处理速度差异。该模型涉及三种线程关系:生产者间、消费者间互斥竞争,生产者和消费者间存在互斥与同步关系。代码实现需使用互斥锁保护共享队列,并通过条件变量实现线程等待/唤醒机制。特别要注意使用while循环而非if判断条件,避免"伪唤醒"问题。这种模式广泛应用于多线程编程中,有效解决了线程间安全高效通信的问题。

2302_77620024的博客 3万+

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Linux详解 --- 多线程3: 线程同步、生产者消费者模型

线程同步、条件变量、生产者消费者模型、基于阻塞队列的生产者消费者模型

wuqiongjin的博客 558

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

Linux多线程编程-生产者与消费者模型详解与实现(C语言)

生产者-消费者模型是并发编程中的经典问题,描述了多个线程(或进程)如何安全、有效地共享有限的缓冲区资源。:负责生成数据或者将数据放置到共享缓冲区中。:负责从共享缓冲区中取出数据并进行处理或消费。

qq_42037383的博客 1305

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Linux 线程同步、互斥锁、生产者消费者模型详解

线程同步: 协同步调,对公共区域数据按序访问。防止数据混乱,产生与时间有关的错误。 锁的使用: 建议锁!对公共数据进行保护。所有线程【应该】在访问公共数据前先拿锁再访问。但,锁本身不具备强制性。 使用mutex(互斥量、互斥锁)一般步骤: pthread_mutex_t 类型。 1. pthread_mutex_t lock; 创建锁 2 pthread_mutex_init; 初始...

一颗牙疼 364

Linux:详解多线程(线程同步、信号量和生产者与消费者模型的实现)(三)

目录

zw的博客 1398

Linux生产者与消费者

Linux生产者与消费者(321原则) 3种关系 生产者与消费者的互斥与同步关系 生产者与生产者的互斥/竞争关系 消费者与消费者的互斥/竞争关系 2种角色 生产者:往交易场所放东西(在计算机中一般都是数据)的人 消费者:从交易场所取东西的人 1个交易场所 内存中具有存储数据的一段有界缓冲区 规则 生产者优先:消费者永远不能追上消费者/生产者; 生产者不能将消费者包一圈。 基于单链表的生产者消费模型...

weixin_45380951的博客 318

《Linux系统编程》Linux 系统多线程(五):<线程同步与互斥>线程同步(上):从条件变量到生产者消费者模型详解

本文深入探讨了Linux线程同步的核心概念与实现方法。首先分析了互斥锁的局限性,指出仅靠互斥无法解决线程饥饿和资源浪费问题。随后重点讲解了条件变量的原理与使用规范,包括其原子性操作特性及避免伪唤醒的while循环判断模式。文章通过生产者消费者模型这一经典案例,详细展示了如何利用双条件变量实现高效线程同步,并提供了单生产单消费、多生产多消费等多种场景的代码实现。最后强调生产者消费者模型的三大优势:解耦、支持忙闲不均和提高并发效率,为开发高并发程序提供了重要范式。

2501_91275995的博客 343

【Linux】线程同步和互斥(2): 自习室+苹果故事详解生产者消费者模型

临界资源:同一时间仅允许一个线程访问的共享资源(VIP自习室、苹果盘子、队列缓冲区);临界区:线程访问临界资源的代码片段(在自习室学习的整个过程);线程同步:约束多线程访问临界资源的顺序,让线程并发更合理、高效、可预测,杜绝不公平竞争与饥饿问题。补充知识点:线程在临界区可以被CPU切换吗?可以!就像你在自习室学习时,可以暂时锁门去卫生间。虽然线程被切换,但临界资源依然被锁定,其他线程无法进入,临界区代码具备原子执行的效果。生产者:由一个或多个线程承担消费者:线程承担商品:数据。

zzzsde的博客 832
上一篇: 【Linux】多线程编程 - 同步/条件变量/信号量
下一篇: 【Linux】网络编程 - 基础概念
Hello_World_213
博客等级 码龄5年 88粉丝 77原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值