Qt进程间通信及内存共享，信号量，锁机制，线程同步

MutexOnly

#ifndef MUTEXONLY_H
#define MUTEXONLY_H

#include <QCoreApplication>
#include <iostream>
#include <QTime>
#include <QMutex>
#include <QThread>
#include <QWaitCondition>

using namespace std;
class MutexOnly
{
public:
//    MutexOnly();
    //预计生产（或消费）数量
    int loopCount;
    //当前产品数量
    int product;
    //仓库能容纳最大产品数量
    int capacity;

    QMutex mutex;


    //QWaitCondition类为线程同步提供了一个条件变量,此处设置条件

    QWaitCondition productIsNotFull;//商店产品不是满的
    QWaitCondition productIsNotEmpty;//商店产品不为空

    //生产者**********************************************************************************

    class Producer:public QThread
    {
    public:
        Producer(MutexOnly *manager) : QThread() {
            this->manager=manager;

    }
    protected:
        void run(){
            for(int i=0;i<manager->loopCount;i++)
            {
                manager->mutex.lock();
                while(manager->product==manager->capacity)
                {
                    //释放该锁，并且阻塞当前线程，直到条件满足（即调用wake方法被唤醒）
                    manager->productIsNotFull.wait(&manager->mutex);
                }
                manager->product++;
                cout<<i<<".P"<<manager->product<<", ";
                manager->productIsNotEmpty.wakeAll();
                manager->mutex.unlock();
            }
        }
    private:
        MutexOnly *manager;
    };




    /****消费者************************************************************************/

    class Consumer:public QThread{

    public:
        Consumer(MutexOnly *manager):QThread(){

            this->manager=manager;

        }

    protected:
        void run(){
            for(int i; i<manager->loopCount;i++)
            {
                manager->mutex.lock();
                while(manager->product==0){
                    manager->productIsNotEmpty.wait(&manager->mutex);
                }
                manager->product--;
                cout<<i<<",C="<<manager->product<<", ";
                manager->productIsNotFull.wakeAll();
                manager->mutex.unlock();
            }

        }

    private:
        MutexOnly *manager;
    };

     /****无修饰方法************************************************************************/
public:
    void test(int loopCount,int capacity)
    {
        this->loopCount=loopCount;
        this->capacity=capacity;
        this->product=0;

        Producer producer(this);
        Consumer consumer(this);
        //thread.start会调用thread内部的run方法
        producer.start();
        consumer.start();



        //接下来阻塞该线程直到所有条件都满足
        producer.wait();
        consumer.wait();
        cout<<endl;

    }

};

#endif // MUTEXONLY_H

MutexWaitCondition

#ifndef MUTEXWAITCONDITION_H
#define MUTEXWAITCONDITION_H

#include <QCoreApplication>
#include <iostream>
#include <QTime>
#include <QMutex>
#include <QThread>
#include <QWaitCondition>

using namespace std;

class MutexWaitCondition
{
public:
    MutexWaitCondition();

public :
    //预计生产（或消费）数量
    int loopCount;
    //当前产品数量
    int product;
    //仓库能容纳最大产品数量
    int capacity;

    QMutex mutex;


    //QWaitCondition类为线程同步提供了一个条件变量,此处设置条件

    QWaitCondition productIsNotFull;//商店产品不是满的
    QWaitCondition productIsNotEmpty;//商店产品不为空

    /*生产者**********************************************************************************/
    class Producer:public QThread
    {
    public:
        Producer(MutexWaitCondition *manager) : QThread() {
            this->manager=manager;

    }
    protected:
        void run(){
            for(int i=0;i<manager->loopCount;i++)
            {
                manager->mutex.lock();
                while(manager->product==manager->capacity)
                {
                    //释放该锁，并且阻塞当前线程，直到条件满足（即调用wake方法被唤醒）
                    manager->productIsNotFull.wait(&manager->mutex);
                }
                manager->product++;
                cout<<i<<".P"<<manager->product<<", ";
                manager->productIsNotEmpty.wakeAll();
                manager->mutex.unlock();
            }
        }
    private:
        MutexWaitCondition *manager;
    };




    /****消费者************************************************************************/


    class Consumer:public QThread{

    public:
        Consumer(MutexWaitCondition *manager):QThread(){

            this->manager=manager;

        }

    protected:
        void run(){
            for(int i; i<manager->loopCount;i++)
            {
                manager->mutex.lock();
                while(manager->product==0){
                    manager->productIsNotEmpty.wait(&manager->mutex);
                }
                manager->product--;
                cout<<i<<",C="<<manager->product<<", ";
                manager->productIsNotFull.wakeAll();
                manager->mutex.unlock();
            }

        }

    private:
        MutexWaitCondition *manager;
    };
    /****无修饰方法************************************************************************/
public:
   void test(int loopCount,int capacity)
   {
       this->loopCount=loopCount;
       this->capacity=capacity;
       this->product=0;

       Producer producer(this);
       Consumer consumer(this);
       //thread.start会调用thread内部的run方法
       producer.start();
       consumer.start();



       //接下来阻塞该线程直到所有条件都满足
       producer.wait();
       consumer.wait();
       cout<<endl;

   }







};

#endif // MUTEXWAITCONDITION_H

SenaphoreMutex

#ifndef SENAPHOREMUTEX_H
#define SENAPHOREMUTEX_H

#include <QCoreApplication>
#include <iostream>
#include <QTime>
#include <QMutex>
#include <QThread>
#include <QWaitCondition>
#include <QSemaphore>
using namespace std;

class SenaphoreMutex
{
public:
    SenaphoreMutex();
public:
    //预计生产（或消费）数量
    int loopCount;
    //当前产品数量
    int product;
    //仓库能容纳最大产品数量
    int capacity;

    QMutex mutex;

    //QSemaphore类提供一个通用的计数信号量,定义了两个信号量对象
    QSemaphore *productSemhore;
    QSemaphore *leftSpaceSemaphore;

    /*生产者*（****************************************************************************************************************/

    class  Producer : public QThread{
    public:
        Producer(SenaphoreMutex *manager): QThread() {
            this->manager=manager;

        }

    protected:
        void run()
        {
            for(int i=0; i<manager->loopCount; i++)
            {
                //尝试获取（减去）n个被信号量控制的资源，如果n大于可用资源数量，它就会阻塞直到有足够的资源为止
                manager->leftSpaceSemaphore->acquire();
                //之所以lock要在acquire后面是因为：如果消费者拿到了锁，那么又没有商品，会导致死锁
                manager->mutex.lock();
                manager->productSemhore->release();
                cout<<i<<".P"<<manager->productSemhore->available()<<",";
                manager->mutex.unlock();

            }
        }

    private:
        SenaphoreMutex *manager;
    };
    \


    /*消费者*********************************************************************************************************************/

    class Consumer : public QThread
    {
    public:
        Consumer(SenaphoreMutex *manager) :QThread(){

            this->manager=manager;


    }
    protected:
        void run(){
            for(int i=0; i<manager->loopCount;i++){
                manager->productSemhore->acquire();
                manager->mutex.lock();

                manager->leftSpaceSemaphore->release();
                cout<<i<<".C="<<manager->productSemhore->available()<<",";
                manager->mutex.unlock();


            }
        }
    private:
        SenaphoreMutex *manager;
    };



    //无修饰的方法 默认是private的****************************************************************************/
public:
    void test(int loopCount,int capacity)
    {
        this->loopCount=loopCount;
        this->capacity=capacity;

        //参数为：信号量的当前值
        productSemhore=new  QSemaphore(0);
        leftSpaceSemaphore=new  QSemaphore(capacity);

        Producer producer(this);
        Consumer consumer(this);

        //thread.start   RUN
        producer.start();
        consumer.start();

        //阻塞该线程直到所有条件都满足
        producer.wait();

    }



};

#endif // SENAPHOREMUTEX_H

#include <QCoreApplication>
#include <QTime>
#include <iostream>
#include "mutexonly.h"
#include "mutexwaitcondition.h"
#include "senaphoremutex.h"


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    using namespace std;



    int loopCount=100;
    int capacity=3;
    QTime time;

    int mutexOnlyElapsed;
    int mutexWaitConditonElapsed;
    int SemaphoreMutexElapsed;
//    cout<<"loopCount ="<<loopCount<<"capacity ="<<capacity<<endl<<endl;
//    cout<<"MutexOnly"<<endl;

//    MutexOnly mutexOnly;
//    time.start();
//    mutexOnly.test(loopCount,capacity);

//    //milliseconds,返回最后一次调用start到现在已经经过的毫秒数
//    mutexOnlyElapsed=time.elapsed();
//    cout<<"elapsed:"<<mutexOnlyElapsed<<"ms"<<endl;
//    cout<<endl;


    cout<<"Mutexwaitcondition"<<endl;
    MutexWaitCondition mutexWaitCondition;
    time.restart();
    mutexWaitConditonElapsed=time.elapsed();

    cout<<"elapsed:"<<mutexWaitConditonElapsed<<"ms"<<endl;
    cout<<endl;



    cout<<'SemaphoreMutex'<<endl;
    SenaphoreMutex SemaphoreMutex;
    time.restart();
    SemaphoreMutex.test(loopCount,capacity);
    SemaphoreMutexElapsed=time.elapsed();
    cout<<"elapsed"<<SemaphoreMutexElapsed<<"ms"<<endl;
    cout<<endl;
    return 0;




    return a.exec();
}