[linux仓库]多线程同步：基于POSIX信号量实现生产者-消费者模型[线程·柒]

原创于 2025-11-12 15:04:03 发布 · 387 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#linux #运维 #System V信号量 #生产者消费者模型 #环形队列

Linux 专栏收录该内容

40 篇文章

订阅专栏

王者杯·14天创作挑战营·第7期 10w+人浏览 287人参与

🌟 各位看官好，我是egoist2023！

🌍 Linux == Linux is not Unix ！

🚀 今天来学习Linux的System V信号量,基于该信号量实现生产者消费者模型的代码。

👍 如果觉得这篇文章有帮助，欢迎您一键三连，分享更多人哦！

回顾System V信号量

还记得这张图不?这是当年在讲进程通信时候,通过讲述电影院的故事,画出的图.上一节我们又有了阻塞队列的知识储备.

阻塞队列当成整体使用,如果此时拆分成一个个小资源呢?让不同的线程访问同一块资源的不同部分,那么不就相当于允许多个线程并发访问同一块资源了吗

整体使用就是要有互斥能力;

局部使用,访问错了,分多资源应该要规避

放过多线程进入,本质就是访问信号量,而信号量本质是一把计数器!(信号量就是一个计数器,可以理解为锁+整数) --> 那么该如何表示信号量还剩多少资源,资源被申请多少了呢? PV操作

要申请信号量 --> 前提是看到同一个信号量 --> 信号量本身就要是共享资源 --> 如何保证自己的安全? --> PV操作是原子性的

让不同的线程,访问同一块资源的不同部分,这个资源在哪里呢?需要让程序员做!

POSIX信号量

POSIX信号量和SystemV信号量作⽤相同，都是⽤于同步操作，达到⽆冲突的访问共享资源⽬的。但POSIX可以⽤于线程间同步。

认识信号量接口

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。

上⼀节⽣产者-消费者的例⼦是基于queue的,其空间可以动态分配,现在基于固定⼤⼩的环形队列重写这个程序（POSIX信号量）:

环形队列

单单CP场景

我们现在有信号量这个计数器，就很简单的进⾏多线程间的同步过程。

为空的时候，必须让生产者先运行 --> 生产和消费会访问同一个位置 --> 互斥放入数据 --> 这不就是生产和消费者的互斥与同步关系!
为满的时候,必须让消费者先运行 --> 生产和消费又指向同一个位置了! --> 互斥的获取数据 --> 这不就是生产和消费者的互斥与同步关系!
不为空 && 不为满:此时首 != 尾 ,访问的一定不是同一个位置! --> 此时,不就可以并发执行了?!

代码实现

信号量Sem.hpp封装

class Sem
{
public:
    Sem(int initnum) : _initnum(initnum)
    {
        sem_init(&_sem, 0, _initnum);
    }

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

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

    ~Sem()
    {
        sem_destroy(&_sem);
    }

private:
    sem_t _sem;
    int _initnum;
};

RingQueue.hpp

static int gcap = 5; // for debug

template <typename T>
class RingQueue
{
public:
    RingQueue(int cap = gcap)
        : _cap(cap), _ring_queue(cap), _space_sem(cap), _data_sem(0), _p_step(0), _c_step(0)
    {
    }

private:
    std::vector<T> _ring_queue; // 临界资源
    int _cap;

    Sem _space_sem;
    Sem _data_sem;

    // 生产和消费的位置
    int _p_step;
    int _c_step;
};

生产数据

因为是单生产单消费:

不担心同时有两个生产者来访问;
生产者访问期间,消费者不可能来打扰我,一定不为满,最多也就是不为空&不为满,二者可以并发执行,消费者并不影响生产者

    void Enqueue(const T &in)
    {
        _space_sem.P();
        {
            // 生产数据了！有空间，在哪里啊？？
            _ring_queue[_p_step++] = in;
            // 维持环形特点
            _p_step %= _cap;
        }
        _data_sem.V();
    }

消费数据

只要消费者走到了*out = _ring_queue[_c_step++,证明队列一定不为空.

    void Pop(T *out)
    {
        _data_sem.P();
        {
            *out = _ring_queue[_c_step++];
            _c_step %= _cap;
        }
        _space_sem.V();
    }

多多CP场景

如果是多生产多消费呢?就还需要维护生产者之间、消费者之间的互斥关系,那要加几把锁呢?一把锁就放弃了让生产者和消费者并发运行的情况,降低效率.引入两把锁,生产者之间竞争这把锁,消费者之间竞争者这把锁,本质还是归宿到单生产单消费了

static int gcap = 5; // for debug

template <typename T>
class RingQueue
{
public:
    RingQueue(int cap = gcap)
        : _cap(cap), _ring_queue(cap), _space_sem(cap), _data_sem(0), _p_step(0), _c_step(0)
    {
    }
    void Pop(T *out)
    {
        _data_sem.P();
        {
            LockGuard lockguard(&_c_lock);
            *out = _ring_queue[_c_step++];
            _c_step %= _cap;
        }
        _space_sem.V();
    }
    void Enqueue(const T &in)
    {
        _space_sem.P();
        {
            LockGuard lockguard(&_p_lock);
            // 生产数据了！有空间，在哪里啊？？
            _ring_queue[_p_step++] = in;
            // 维持环形特点
            _p_step %= _cap;
        }
        _data_sem.V();
    }
    ~RingQueue()
    {
    }

private:
    std::vector<T> _ring_queue; // 临界资源
    int _cap;

    Sem _space_sem;
    Sem _data_sem;

    // 生产和消费的位置
    int _p_step;
    int _c_step;

    // 两把锁
    Mutex _p_lock;
    Mutex _c_lock;
};

main.cc

// 基于信号量形成的生产者消费者模型
void *consumer(void *args)
{
    RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);
    while (true)
    {
        int data = 0;
        rq->Pop(&data);
        std::cout << "消费了一个数据: " << data << std::endl;
    }
}

void *productor(void *args)
{
    RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);

    int data = 1;
    while (true)
    {
        sleep(1);
        rq->Enqueue(data);
        std::cout << "生产了一个数据: " << data << std::endl;
        data++;
    }
}

int main()
{
    RingQueue<int> *rq = new RingQueue<int>();
    pthread_t c[2], p[3];

    pthread_create(c, nullptr, consumer, (void *)rq);
    pthread_create(c + 1, nullptr, consumer, (void *)rq);
    pthread_create(p, nullptr, productor, (void *)rq);
    pthread_create(p + 1, nullptr, productor, (void *)rq);
    pthread_create(p + 3, nullptr, productor, (void *)rq);

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

    delete rq;
    return 0;
}

总结

本文介绍了Linux系统中信号量的概念及其在多线程编程中的应用。首先回顾了SystemV信号量的工作原理，通过计数器机制实现资源共享。然后详细讲解了POSIX信号量接口（sem_init、sem_wait等）及其在线程同步中的使用方法。文章重点演示了如何基于环形队列实现生产者-消费者模型，包括单生产单消费和多生产多消费场景的实现方案，并提供了完整的代码示例。最后，针对多线程环境提出了使用两把锁的解决方案，以平衡并发性能与线程安全性。