Qt 多线程同步之信号量

爱被打了一巴掌 2022-10-22 15:53 257阅读 0赞

# 1.原理 #

信号量是另一种限制对共享资源进行访问的线程同步机制，它与互斥量相似，但是有区别。一个互斥量只能被锁定一次，而信号量可以多次使用。信号量通常用来保护一定数量的相同的资源，如数据采集时的双缓冲区。

**QSemaphore常用方法**

*  acquire(int n)尝试获得n个资源。如果没有这么多资源，线程将阻塞直到有n个资源可用。
 *  release(int n)释放n个资源，如果信号量的资源已全部可用之后再release()，就可以创建更多的资源，增加可用资源的个数。
 *  int available()返回当前信号量可用的资源个数，这个数永远不可能为负数，如果为0，就说明当前没有资源可用。
 *  bool tryAcquire(int n =1)尝试获取n个资源，不成功时不阻塞线程。

QSemaphore sp(5);    //sp.available() == 5,初始资源个数为5个
    sp.acquire(4);       //sp.available() == 1,用了4个资源，还剩余1个可用
    sp.release(2);       //sp.available() == 3,释放了2个资源，还剩余3个可用
    sp.acquire(3);       //sp.available() == 0,用了3个资源，还剩余0个可用
    sp.tryAcquire(1);    //sp.available() == 0,返回false
    sp.acquire();        //sp.available() == 0,没有资源可用 ，阻塞

上面代码可以这样理解

假设sp为一个公共卫生间，初始化时定义有5个位置。

*  sp.acquire(4)：进来了4个人，占用了4个位置，还剩一个位置。
 *  sp.release(2)：出去了2个人，还剩3个位置。
 *  sp.acquire(3)：又进来了3个人，还剩余0个位置
 *  sp.tryAcquire(1)：有一个人尝试进去，但是因为没有位置，他不等待走了。
 *  sp.acquire()：有一个人必须要进去，但是因为没有位置了，他就一直等待有人出来。

# 2.示例 #

双缓冲区数据采集和读取线程

#ifndef MYTHREAD_H
    #define MYTHREAD_H
    
    #include <QThread>
    #include <QQueue>
    #include <QSemaphore>
    
    static const int bufferSize = 8;
    static int buffer1[bufferSize];
    static int buffer2[bufferSize];
    
    //当前正在写入的buffer
    static int curBuf = 1;
    
    //采集的缓冲区序号
    static int bufNo = 0;
    
    //数据生成器
    quint8 counter = 0;
    
    //空的缓冲区个数，初始资源为2
    QSemaphore emptyBufs(2);
    
    //满的缓冲区个数，初始资源为0
    QSemaphore fullBufs;
    
    
    class Producer : public QThread
    {
        Q_OBJECT
    public:
        explicit Producer(QThread *parent)
            :QThread(parent)
        {
    
        }
    
    protected:
        void run()
        {
            m_stop = false;
    
            //缓冲区序号
            bufNo = 0;
    
            //当前写入使用的缓冲区
            curBuf = 1;
    
            //数据生成器
            counter = 0;
    
            int n = emptyBufs.available();
    
            //保证线程启动时emptyBufs.available() == 2
            if(n < 2)
                emptyBufs.release(2-n);
            while(!m_stop)
            {
                //获取一个空的缓冲区
                emptyBufs.acquire();
    
                //产生一个缓冲区的数据
                for(int i=0;i<bufferSize;i++)
                {
                    if(curBuf == 1)
                        buffer1[i] = counter;  //向缓冲区写入数据
                    else
                        buffer2[i] = counter;  //向缓冲区写入数据
    
                    //模拟数据采集卡产生数据
                    counter++;
    
                    //每50ms产生一个数
                    msleep(50);
                }
                //缓冲区序号
                bufNo++;
    
                //切换当前写入缓冲区
                if(curBuf == 1)
                    curBuf = 2;
                else
                    curBuf = 1;
    
                //有了一个满的缓冲区，available == 1
                fullBufs.release();
            }
        }
    private:
        bool m_stop;
    };
    
    class Customer : public QThread
    {
        Q_OBJECT
        
    Q_SIGNALS:
        void newValue(int *data,int count,int seq);
    public:
        explicit Customer(QThread *parent):QThread(parent)
        {
    
        }
    protected:
        void run()
        {
            m_stop = false;
            int n = fullBufs.available();
            if(n > 0)
                fullBufs.acquire(n); //将fullBufs可用资源个数初始化为0
            while(!m_stop)
            {
                //等待有缓冲区满，当fullBufs.available == 0阻塞
                fullBufs.acquire();
                
                int bufferData[bufferSize];
                int seq = bufNo;
                
                if(curBuf == 1)
                    for(int i=0;i<bufferSize;i++)
                        bufferData[i] = buffer2[i];
                else
                    for(int i=0;i<bufferSize;i++)
                        bufferData[i] = buffer1[i];
                
                //释放一个空缓冲区
                emptyBufs.release();
                
                //给主线程发送数据
                emit newValue(bufferData,bufferSize,seq);
            }
        }
    
    private:
         bool m_stop;
    };
    
    
    
    #endif // MYTHREAD_H