Qt入门练习项目——生产者消费者模型（多线程与自定义信号）

最新推荐文章于 2024-06-11 08:56:36 发布
最新推荐文章于 2024-06-11 08:56:36 发布
阅读量1.9k 收藏 24
点赞数 6
分类专栏： Qt入门练手项目 文章标签： qt5 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45219779/article/details/107732336
版权

通过生产者消费者模型了解Qt的多线程和自定义信号的使用

效果如下图：
在这里插入图片描述
生产者消费者模型分析：
  

  • 界面：操作和接收信号
     连接生产者和消费者
  • 生产者（ThreadOne类）：生产商品
     开辟新线程生产商品并存入仓库
  • 消费者（ThreadTwo类）：消费商品
     从仓库取出商品
  • 仓库（WareHouse类）：管理商品并与界面进行交互
     负责管理商品的存和取，通过锁的机制构成安全队列
    QQueue< QString > m_cargo（仓库队列）
具体代码如下：
1. 界面
{
	ui = new Ui::thirdQtClass();
    ui->setupUi(this);
	this->setFixedSize(1300,610);
	this->setWindowTitle("产者消费者模型");
	this->setWindowIcon(QIcon("H:/Document/VS/thirdQt/shop.ico"));
	ui->TE_producer->setReadOnly(true);
	ui->TE_consumer->setReadOnly(true);
	ui->CB_producer->setMaxVisibleItems(20);
	ui->CB_consumer->setMaxVisibleItems(30);

	wh = new WareHouse();

	
	//生产者
	connect(ui->PB_producerAdd,SIGNAL(clicked()),this,SLOT(on_producerAdd_click()));
	connect(ui->PB_producerChange, SIGNAL(clicked()), this, SLOT(on_producerChange_click()));
	connect(ui->PB_producerMinus, SIGNAL(clicked()), this, SLOT(on_producerMinus_click()));
	connect(ui->PB_producerOpen, SIGNAL(clicked()), this, SLOT(on_Order_click()));
	connect(ui->PB_producerPause, SIGNAL(clicked()), this, SLOT(on_Order_click()));
	//消费者
	connect(ui->PB_consumerAdd, SIGNAL(clicked()), this, SLOT(on_consumerAdd_click()));
	connect(ui->PB_consumerChange, SIGNAL(clicked()), this, SLOT(on_consumerChange_click()));
	connect(ui->PB_consumerMinus, SIGNAL(clicked()), this, SLOT(on_consumerMinus_click()));
	connect(ui->PB_consumerOpen, SIGNAL(clicked()), this, SLOT(on_Order_click()));
	connect(ui->PB_consumerPause, SIGNAL(clicked()), this, SLOT(on_Order_click()));
	//日志
	connect(wh,SIGNAL(pushOk(int)),this,
		SLOT(on_outProducer_pushOk(int)), Qt::BlockingQueuedConnection);//发出信号后 线程阻塞 直至槽函数完成  在接收方线程操作
	connect(wh,SIGNAL(takeOk(int)),this,
		SLOT(on_outConsumer_takeOk(int)),Qt::QueuedConnection);//发出信号 等待接收信号方函数完成后再调用	在接收方线程操作


}
//生产者
void thirdQt::on_producerAdd_click()
{
	int n = ui->CB_producer->count();
	QString producer = "";
	if (n > 20)
	{

		QMessageBox::warning(this, "警告", "生产者已至上限！", QMessageBox::Ok, QMessageBox::NoButton);
	}
	else
	{
		producer = QString::number(n);
		QString str = "生产者" + producer;
		ThreadOne * prod = new ThreadOne(wh);
		ui->CB_producer->addItem(str,int(prod));
		ui->CB_producer->setCurrentIndex(n);
	}
	


}
void thirdQt::on_producerChange_click()
{
	int n = ui->LE_producer->text().toInt();
	if (n == 0||n>10000)
	{
		QMessageBox::information(this,"提示","不能为0 且不能大于10000",QMessageBox::Ok,QMessageBox::NoButton);
	}
	else
	{
		wh->changeProduction(n);
	}
	
}
void thirdQt::on_producerMinus_click()
{
	int n = ui->CB_producer->count();
	if (n != 0)
	{
		n--;
		ThreadOne *po = (ThreadOne *)(ui->CB_producer->itemData(n).toInt());
		bool stop = true;
		po->deleteProducer(stop);
		po->terminate();
		po->quit();
		//po->wait();
		delete po;
		po = NULL;
		ui->CB_producer->removeItem(n);//removeItem 中的数字为下标数
	} 
	else
	{
		QMessageBox::warning(this,"警告","生产者已为空",QMessageBox::Ok,QMessageBox::NoButton);
	}
	ui->CB_producer->setCurrentIndex(n-1);
}
void thirdQt::on_outProducer_pushOk(int _size)
{
	ui->TE_producer->append("生产完成 当前商品数为：" + QString::number(_size));
	ui->L_producer->setText("生产总额："+ QString::number(wh->countPush()));
}




void thirdQt::on_Order_click()
{
	on_producerChange_click();
	on_consumerChange_click();
	QPushButton *p = static_cast<QPushButton *>(sender());
	QString str = p->text();
	if (str == "开始生产" || str == "暂停生产")
	{
		for (size_t i = 0; i < ui->CB_producer->count(); i++)
		{
			ThreadOne* po = (ThreadOne*)(ui->CB_producer->itemData(i).toInt());
			po->startProduction(true);
			if (str == "暂停生产")
			{
				po->startProduction(false);
			}
			else
			{

				if (!po->isRunning())
				{
					po->start();

				}
			}
		}
	}
	else
	{
		for (size_t i = 0; i < ui->CB_consumer->count(); i++)
		{
			ThreadTwo* po = (ThreadTwo*)(ui->CB_consumer->itemData(i).toInt());
			po->startConsumption(true);
			if (str == "暂停消费")
			{
				po->startConsumption(false);
			}
			else
			{

				if (!po->isRunning())
				{
					po->start();
				}
			}
		}
	}
}

//消费者
void thirdQt::on_consumerAdd_click()
{
	int n = ui->CB_consumer->count();
	QString consumer = "";
	if (n >30)
	{

		QMessageBox::warning(this, "警告", "消费者已至上限！", QMessageBox::Ok, QMessageBox::NoButton);
	}
	else
	{
		consumer = QString::number(n);
		QString str = "消费者" + consumer;
		ThreadTwo * csm = new ThreadTwo(wh);
		ui->CB_consumer->addItem(str,int(csm));
		ui->CB_consumer->setCurrentIndex(n);
	}

} 

void thirdQt::on_consumerChange_click()
{


	int n = ui->LE_consumer->text().toInt();
	if (n == 0 || n>10000)
	{
		QMessageBox::information(this, "提示", "不能为0 且不能大于10000", QMessageBox::Ok, QMessageBox::NoButton);
	}
	else
	{
		wh->changeConsumption(n);
	}
}
void thirdQt::on_consumerMinus_click()
{
	int n = ui->CB_consumer->count();
	if (n != 0)
	{
		ThreadTwo * po = (ThreadTwo*)(ui->CB_consumer->itemData(n-1).toInt());
		bool stop = true;
		po->deldetComsumption(stop);
		po->terminate();
		po->quit();
		delete po;
		po = NULL;
		ui->CB_consumer->removeItem(n-1);//removeItem 中的数字为下标数
	}
	else
	{
		QMessageBox::warning(this, "警告", "消费者已为空", QMessageBox::Ok, QMessageBox::NoButton);
	}
	ui->CB_consumer->setCurrentIndex(n - 2);
}
void thirdQt::on_outConsumer_takeOk(int _size)
{
	if (_size == 0)
	{
		ui->TE_consumer->append(QString("暂无商品"));
	}
	else
	{
		QString str = "消费完成 商品剩余：" + QString::number(_size);
		ui->TE_consumer->append(str);
		ui->L_consumer->setText( "消费总额："+QString::number(wh->countTake()));
	}

}

一些基本的信号与槽函数的连接和功能的实现

  添加生产者

void thirdQt::on_producerAdd_click()
{
	int n = ui->CB_producer->count();
	QString producer = "";
	if (n > 20)
	{
		QMessageBox::warning(this, "警告", "生产者已至上限！", QMessageBox::Ok, QMessageBox::NoButton);
	}
	else
	{
		producer = QString::number(n);
		QString str = "生产者" + producer;
		ThreadOne * prod = new ThreadOne(wh);
		ui->CB_producer->addItem(str,int(prod));
		ui->CB_producer->setCurrentIndex(n);
	}
}

利用QComboBox类的属性，每添加一个消费者就new出一个生产者类（ThreadOne）的对象，并将地址存入QComboBox的菜单项的QVariant()中。
这里可以了解QComboBox类的一些功能，QComboBox类的addItem()可以传递一个QString，和一个QVariant()。

QString str = "生产者" + producer;
		ThreadOne * prod = new ThreadOne(wh);
		ui->CB_producer->addItem(str,int(prod));

  既当我们添加一个菜单项的同时为这个菜单项绑定一个看不见的数据。这里我们存放ThreadOne对象的指针。
  消费者同理

  • 开始按钮
      生产者和消费者公用一个槽函数。添加生产者或消费者后按下开始后，通过遍历将菜单栏中对应的对象取出，并判断是否为启动状态（isRunning()）,若该生产者（消费者）未启动，则start()开启线程。
void thirdQt::on_Order_click()
{
	on_producerChange_click();
	on_consumerChange_click();
	QPushButton *p = static_cast<QPushButton *>(sender());
	QString str = p->text();
	if (str == "开始生产" || str == "暂停生产")
	{
		for (size_t i = 0; i < ui->CB_producer->count(); i++)
		{
			ThreadOne* po = (ThreadOne*)(ui->CB_producer->itemData(i).toInt());
			po->startProduction(true);
			if (str == "暂停生产")
			{
				po->startProduction(false);
			}
			else
			{

				if (!po->isRunning())
				{
					po->start();

				}
			}
		}
	}
	else
	{
		for (size_t i = 0; i < ui->CB_consumer->count(); i++)
		{
			ThreadTwo* po = (ThreadTwo*)(ui->CB_consumer->itemData(i).toInt());
			po->startConsumption(true);
			if (str == "暂停消费")
			{
				po->startConsumption(false);
			}
			else
			{

				if (!po->isRunning())
				{
					po->start();
				}
			}
		}
	}
}
  • 删除消费者（生产者）
      与添加类似，先拿出菜单中的末尾项所绑定的对象，终止线程 并删除指针，最后删除菜单项
void thirdQt::on_consumerMinus_click()
{
	int n = ui->CB_consumer->count();
	if (n != 0)
	{
		ThreadTwo * po = (ThreadTwo*)(ui->CB_consumer->itemData(n-1).toInt());
		bool stop = true;
		po->deldetComsumption(stop);
		po->terminate();
		po->quit();
		delete po;
		po = NULL;
		ui->CB_consumer->removeItem(n-1);//removeItem 中的数字为下标数
		ui->CB_consumer->setCurrentIndex(n - 2);
	}
	else
	{
		QMessageBox::warning(this, "警告", "消费者已为空", QMessageBox::Ok, QMessageBox::NoButton);
	}

}

connect(wh,SIGNAL(pushOk(int)),this,
		SLOT(on_outProducer_pushOk(int)), Qt::BlockingQueuedConnection);//发出信号后 线程阻塞 直至槽函数完成  在接收方线程操作
	connect(wh,SIGNAL(takeOk(int)),this,
		SLOT(on_outConsumer_takeOk(int)),Qt::QueuedConnection);//发出信号 等待接收信号方函数完成后再调用	在接收方线程操作

接收来自仓库的带参的自定义信号pushOk()、takeOk()、其中参数分别为存入和取出后仓库商品数量。
    connect()的第五参数: Qt::BlockingQueuedConnection
              Qt::QueuedConnection      
这两种注释有解释
值得注意的是默认状态下若信号与槽函数不在同一线程则默认使用 ： Qt::DirectConnection
  Qt::DirectConnection：槽函数会在信号发送的时候直接被调用，槽函数运行于信号发送者所在线程。但当线程过多时可能导致线程崩溃，所以主动设置第五参数为最优选择。

2. 生产者

wh 是仓库的对象，通过此对象操作仓库的函数。

ThreadOne::ThreadOne(WareHouse *wh)
{
	m_wh = wh;
	begin = false;
	stop = false;

}
void ThreadOne::startProduction(bool order)
{
	begin = order;

}
void ThreadOne::run()
{
	while (!stop)
	{
		while (begin)
		{
			QString commodity = "¥";
			m_wh->pushCargo(commodity);
			msleep(50);
			begin = order();
		}
		stop = getDelete();
		sleep(1);
	}
}
bool ThreadOne::order()
{

	return begin;
}
void ThreadOne::deleteProducer(bool stop1)
{
	stop = stop1;
}
bool ThreadOne::getDelete()
{
	return stop;
}

ThreadOne类继承自QThread类，此类负责Qt的多线程
QThread中有一个run()的虚函数，继承并重写后的run()函数将在新的线程中执行，所以想要实现多线程就需要新建一个类继承QThread()并重写run()函数。

void ThreadOne::run()
{
	while (!stop)
	{
		while (begin)
		{
			QString commodity = "¥";
			m_wh->pushCargo(commodity);
			msleep(50);
			begin = order();
		}
		stop = getDelete();
		sleep(1);
	}
}
  1. 消费者

大体上与生产者相似 run()外的函数用来控制暂停和停止

#include "ThreadTwo.h"
ThreadTwo::ThreadTwo(WareHouse * wh)
{
	m_wh = wh;
	stop = false;
}
void ThreadTwo::run()
{
	while (!stop)
	{
		while (begin)
		{
			QString consumer = m_wh->takeCargo();
			msleep(80);
			begin = order();
		}
		sleep(1);
		stop = getDelete();
	}
}
void ThreadTwo::startConsumption(bool order)
{
	begin = order;
}

bool ThreadTwo::order()
{
	return begin;
}
void ThreadTwo::deldetComsumption(bool stop1)
{
	stop = stop1;
}
bool ThreadTwo::getDelete()
{
	return stop;
}
  1. 仓库

自定义两个带参信号：signals:
          void pushOk(int);
           void takeOk(int);
  存取操作都使用了QMutex类（锁），为了防止不同对象访问队列形成冲突，通过加锁的形式保证仓库为一个安全队列。（当对象开始访问队列 触发lock()状态，使其他对象无法进入，当操作完成后 触发unlock()打开队列锁结束访问 ）。
  每当生产者生产的商品被存入队列，WareHouse 便发送一个带有仓库数量参数的信号（pushOk() ）返回给界面。
  同理每当消费者拿走一个商品，仓库便删除一个商品，并发送一个带有仓库数量参数的信号（takeOk() ）返回给界面。

WareHouse::WareHouse()
{
	mutex = new QMutex();
	m_push = 0;
	m_take = 0;
	m_sleepP = 0;
	m_sleepC = 0;
}
//存入商品
void WareHouse::pushCargo(QString commodity)
{
	mutex->lock();
	m_push++;
	m_cargo.enqueue(commodity);
	emit pushOk(m_cargo.size());
	mutex->unlock();
	QThread::msleep(getChangeP());
	
}
//消费商品
QString  WareHouse::takeCargo()
{
	QString str = "";
	mutex->lock();
	if (m_cargo.count() != 0)
	{
		str = m_cargo.dequeue();
		emit takeOk(m_cargo.size());
		m_take++;
	}
	else
	{
		emit takeOk(0);
	}
	mutex->unlock();
	QThread::msleep(getChangeC());
	return str;
}
int WareHouse::countPush()
{
	int pushSize = m_push;
	return pushSize;
}
int WareHouse::countTake()
{
	int takeSize = m_take;
	return takeSize;
}

void WareHouse::changeProduction(int datas)
{
	 m_sleepP = 10000 / datas;
}
int WareHouse::getChangeP()
{
	int n = m_sleepP;
	return n;
}
void WareHouse::changeConsumption(int datas)
{
	m_sleepC = 10000 / datas;
}
int WareHouse::getChangeC()
{
	int n = m_sleepC;
	return n;
}

以上便是本项目的主要代码，有问题或建议请在评论区交流，如需源码请转至：资源下载中心

Pointer=NULL
关注
  • 6
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Qt之线程同步（生产者消费者模式 - QSemaphore）
青春不老，奋斗不止！
09-23 1万+
生产者将数据写入缓冲区，直到它到达缓冲区的末尾，此时，它将从开始位置重新启动，覆盖现有数据。消费者线程读取数据并将其写入标准错误。
Qt线程同步——生产者消费者模式（QSemaphore）
百叶书的博客
09-16 1079
生产者消费者模式 在实际的软件开发过程中，经常碰到一个场景：某个模块负责产生数据，这些数据由另一个模块负责处理。 产生数据的模块称为生产者，处理数据的模块称为消费者。 在生产者和消费者之间有个中介，称为缓冲区。 缓冲区的作用： （1）解耦：使生产者和消费者之间不形成直接依赖，耦合降低； （2）并发：生产者和消费者成为两个并发独立主体。生产者将数据丢至缓冲区，就去生产下一个数据，不依赖消费者的处理速度。 （3）支持忙闲不均。 ...
Qt多线程同步-生产者消费者模式
最新发布
qq_42692132的博客
06-11 260
Qt多线程同步-生产者消费者模式
QT 生产者消费者模型
crazy_nakahara的博客
03-24 606
利用QT官方推荐的多线程的方法建立生产者消费者模型
【Qt线程-5】生产者&消费者模型应用（多态，子线程控制，协同，事件循环）
大橘子的博客
02-21 2264
主窗体作为主界面和中转仓库。可以直观看到仓库存量和中转计数，可以清空仓库和计数，可以调整仓库容量，可以新建/销毁各单位，可以看到各单位列表。 生产者和消费者，每个单位都是独立的个体，都有各自独立的窗体。可以启动/停止工作，可以设置缓存大小，可以设置工作延时（工作速度），可以看到缓存流动情况和计数。
【qt实现生产者消费者】
qq_53175673的博客
10-17 661
操作系统是四大件之一，这里为了完成对应的生产者消费者实验，用qt进行了实现。本文就介绍一下怎么用qt的多线程来实现生产者消费者。（本文主要注重代码的实现，原理部分如信号量就不详细讲啦）这里讨论最简单的，一个生产者和一个消费者对一片缓冲区进行读写操作。当缓冲区满时，生产者不能再进行生产，当缓冲区为空时，消费者不能再进行消费。接下来上一段的代码，介绍一下p,v操作的实现sleep(1);//睡眠一秒 } s --;s ++;}这里两个原语操作，s可以为对应的缓冲资源，以及互斥变量mutex。
生产者消费者模型(Qt实现)
qq_45830912的博客
05-19 2413
//mainwindow.h #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include<QObject> #include<windows.h> #include <QtCore/QCoreApplication> #include <QSemaphore> #include <QThread> #include <QMutex>.
qt多线程-条件变量实现生产者消费者
猫步旅人
11-09 502
逻辑基本都写在注释里所以直接上生产者和消费者类的代码环境producer.hproducer.cppconsumer.hconsumer.cpp源码地址 github 环境 VS2017+QT producer.h #pragma once #include <QMutex> #include <QWaitCondition> #include <QThread> #include <iostream> #include <deque> us
Qt入门练习项目——生产者消费者模型.zip
08-01
**Qt入门练习项目——生产者消费者模型** 在编程领域，生产者消费者模型是一种常见的多线程同步问题的解决方案。这个模型通常用于处理数据流的异步处理，其中一个或多个线程（生产者）生成数据，而其他线程（消费者...
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
08-11
Qt入门（七）——TCP传输协议（利用多线程实现多个客户机与服务器连接）
QT窗口界面模拟生产者消费者
04-10
在QT中，实现生产者-消费者模型的关键在于正确地使用多线程机制。QT提供了一种名为`QThread`的类，可以方便地创建和管理线程。在描述中提到，程序是通过子类化`QThread`来创建自定义的生产者和消费者线程。子类化`...
12.2 Qt5多线程：使用信号量实现生产者和消费者
02-15
Qt5多线程，使用QSemaphore类实现生产者和消费者问题。
Qt C++11 生产者消费者模式类
07-11
使用Qt 和 C++11 的std::mutex 和 std::condition_variable 实现一个演示生产者消费者模式的Qt工程。
使用Qt信号量实现单生产者多消费者模型
10-15
基于Qt信号量实现的单生产者多消费者模式下的消息队列，可在多线程应用中对不同的消息结构体进行数据传输。
生产者消费者多进程模型Qt
05-19
用Qt实现的生产者消费者模型（多进程），操作系统课程作业。 4消费者，4生产者，12缓冲区，可视化展示。
Qt中使用QSemaphore，单生产者—多消费者模型
03-15
Qt中QSemaphore信号量与QMutexLocker、QMutex的使用，单生产者-多消费者模型；界面可设置消费者线程数量；
Qt之线程同步（生产者消费者模式 - QWaitCondition）
热门推荐
青春不老，奋斗不止！
09-23 1万+
生产者将数据写入缓冲区，直到它到达缓冲区的末尾，这时，它从开始位置重新启动，覆盖现有数据。消费者线程读取数据并将其写入标准错误。
QTcreator 多线程（生产者消费者）
蹦跳的摩羯的博客
03-16 1305
qt应用的多线程实例简单实现，语法超级简单，用两种方法实现同步和互斥。一种是Semaphore信号量，另一种是mutex锁和condition条件变量。下面开始。第一种，QSemaphore信号量方式：通过Qt Creator创建一个控制台项目，项目创建完以后只有一个main.cpp文件和一个.pro配置文件，在main.cpp添加如下内容#include &lt;QCoreApplication...
QT 线程，实现生产者-消费者模式
LearnLHC的博客
03-30 1879
一、两种启动线程方式： 1、QThread 2、QObject::moveToThread() 函数 可以让 调用者的 槽中的代码，在单独的线程执行。 注：如果该对象有 父对象，那么它无法被移动。 二、线程同步 ①、QMutex： 互斥锁 ②、QReadWriteLock 读写锁的功能。读写锁是用来保护可以被读访问和写访问的资源的一种同步工具。 如果你想让多个线程同时的对资源进行读访问，但只要有一个线程要对资源进行写访问时，所有其他的线程必须等待，直到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Pointer=NULL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值