I am developing an application with Qt 5.9.4 and i have a class derived on QThread
class LogOperations : public QThread
{
Q_OBJECT
public:
LogOperations(QString path,QStringList args,int threadID);
~LogOperations();
void setFileName(QString path);
void setArguments(QStringList ar);
void run();
};
and there is a mainwindow which i create and start those threads in it.
First, i create a QList that holds a pointer to that QThread Class
QList<LogOperations *> threadList;
Then i am simply creating the threads like this
for(int i=0;i<ls.count();i++)
{
threadList.append(new LogOperations(ls.at(i),args,i));
threadList.at(i)->start();
}
But if there are 5-10 threads it's working fine but if there are to many (like 20 or above) threads, the application crashes, how can i handle these threads? any thought?
Related
I'am learning QT multithreading.
With the following code, it works ok, but there are two type errors
The code is too simple to figure out what's going wrong.
CmdController(Controller thread) -> CMD(Ping test thread) -> QProcess(excute "ping")
main.c
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
// create Test object, and then execute “ping” cmd under windows
CmdController Test;
Test.process();
return a.exec();
}
CmdController.h
// deal with "ping" command
class Cmd : public QObject
{
Q_OBJECT
public:
explicit Cmd();
private:
QProcess CmdExe;
public slots:
void process();
void readFromStdOut();
};
// Controller class
class CmdController : public QObject
{
Q_OBJECT
public:
explicit CmdController();
~CmdController();
signals:
void process();
private:
QThread mThread;
Cmd mCmd;
};
CmdController.c
Cmd::Cmd()
{
connect(&CmdExe, SIGNAL(readyReadStandardOutput()), this, SLOT(readFromStdOut()));
}
void Cmd::process()
{
CmdExe.start("ping", {"www.baidu.com"});
}
void Cmd::readFromStdOut()
{
QByteArray resault = CmdExe.readAllStandardOutput();
qDebug() << QTextCodec::codecForName("GBK")->toUnicode(resault);
}
CmdController::CmdController()
{
mCmd.moveToThread(&mThread);
connect(this, &CmdController::process, &mCmd, &Cmd::process);
mThread.start();
}
CmdController::~CmdController()
{
mThread.exit();
mThread.wait();
}
The output:
QObject: Cannot create children for a parent that is in a different thread.
(Parent is QProcess(0x6ffdf0), parent's thread is QThread(0x1f6510), current thread is QThread(0x6ffdd0)
QObject: Cannot create children for a parent that is in a different thread.
(Parent is QProcess(0x6ffdf0), parent's thread is QThread(0x1f6510), current thread is QThread(0x6ffdd0)
QObject: Cannot create children for a parent that is in a different thread.
(Parent is QProcess(0x6ffdf0), parent's thread is QThread(0x1f6510), current thread is QThread(0x6ffdd0)
"\r\n正在 Ping www.a.shifen.com [180.101.49.42] 具有 32 字节的数据:\r\n"
"来自 180.101.49.42 的回复: 字节=32 时间=31ms TTL=53\r\n"
"来自 180.101.49.42 的回复: 字节=32 时间=31ms TTL=53\r\n"
"来自 180.101.49.42 的回复: 字节=32 时间=30ms TTL=53\r\n"
"来自 180.101.49.42 的回复: 字节=32 时间=30ms TTL=53\r\n\r\n180.101.49.42 的 Ping 统计信息:\r\n 数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，\r\n往返行程的估计时间(以毫秒为单位):\r\n 最短 = 30ms，最长 = 31ms，平均 = 30ms\r\n"
QObject::connect: Cannot queue arguments of type 'HANDLE'
(Make sure 'HANDLE' is registered using qRegisterMetaType().)
Error 1st:
1-6 lines output error, shows creating children object fails, by three times.
The ping test is ok.
so, who cause the error?
QThread(0x6ffdd0) is Cmd-object,
QThread(0x1f6510) is CmdController-object,
QProcess(0x6ffdf0) clearly is QProcess-object,
does it mean the QProcess, try to create something?
Error 2ed:
last two lines.
googled, cann't find 'HANDLE' what it is.
If if remove multithreading stuff from
CmdController(Controller thread) -> CMD(Ping test thread) -> QProcess(excute "ping")
to
CmdController(Controller thread) -> QProcess(excute "ping")
there will be no error, everything works perfectly.
I'am confused.
Thank you.
To understand the problem, one must first be clear that a QObject must be executed only in the thread to which it belongs, if another thread is executed then Qt does not guarantee that it works, and that is what has happened in this case.
Let's analyze to which thread each QObject belongs, by default QObject belongs to the thread where it was created or to the thread of its father, so when you create the object "Test" this belongs the main thread, the object "mCmd" at the beginning belongs to the main thread and then you move it to "mThread", "CmdExe" belongs to the thread where it was created, that is to say to the main thread but the "Cmd" process method is executed in the secondary thread but "CmdExe" is executed in the main thread causing the problem.
The solution is to make "CmdExe" the son of "Cmd" so that both belong to the same thread and not generate problems.
// ...
class Cmd : public QObject
{
Q_OBJECT
public:
explicit Cmd(QObject *parent=nullptr);
private:
QProcess *CmdExe;
public slots:
void process();
void readFromStdOut();
};
// ...
// ...
Cmd::Cmd(QObject *parent):QObject(parent), CmdExe(new QProcess(this))
{
connect(CmdExe, &QProcess::readyReadStandardOutput, this, &Cmd::readFromStdOut);
}
void Cmd::process()
{
CmdExe->start("ping", {"www.baidu.com"});
}
// ...
I have a program which has class MainWindow that inherited from QMainWindow.
I want to run a specific function in a new thread.
Since I can't inherit from QThread so the best solution is to use QtConcurrent.
I stored QtConcurrent result in a QFuture but as mentioned in the QT documentation, the result of QtConcurrent can not be canceled by QFuture::cancel.
I see some questions like mine but the answers are to create a class which inherit from QThread that I can't.
So what is the solution?
Here is my codes:
mainwindow.h:
using namespace std;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
...
private:
Ui::MainWindow *ui;
...
QFuture<void> future;
QFutureWatcher< void > futureWatcher;
QPushButton *stop_pushButton_=new QPushButton;
private slots:
...
void on_graph_pushButton_clicked();
void generateGraph();
void stopPushButtonClicked();
};
mainwindow.cpp:
void MainWindow::stopPushButtonClicked()
{
futureWatcher.setFuture(future);
futureWatcher.cancel();
futureWatcher.waitForFinished();
}
...
void MainWindow::on_graph_pushButton_clicked()
{
loadingOn();
future = QtConcurrent::run(this,&MainWindow::generateGraph);
}
void MainWindow::generateGraph()
{
InsertLogs::getInstance()->printStatus(USER_GENERATE_GRAPH);
GenGraph* gr=new GenGraph;
connect(this,&MainWindow::loadingOffSignal,this,&MainWindow::loadingOff);
graphType_=gr->generateGraph(persons_comboBox_->currentText(),
ui->graphResource1_comboBox->currentText(),
ui->graphResource2_comboBox->currentText(),
ui->graphType_comboBox->currentText());
InsertLogs::getInstance()->printSuccess(SYSTEM_GENERATE_GRAPH);
emit loadingOffSignal();
}
When I click on graph_pushButton, generatedGraph is called in a new thread, but when I click on stop_pushButton the future does not stop and the generatedGraph function executes completely.
I'm currently trying to make a software that downloads a lot of files from Google Drive. Downloading is currently not a problem.
Nevertheless, I encounter an issue when launching 500+ simultaneous downloads. I use a slightly modified version of this tutorial : https://wiki.qt.io/Download_Data_from_URL.
Here is the .h file :
class FileDownloader : public QObject
{
Q_OBJECT
public:
explicit FileDownloader(QUrl url, QObject *parent = 0, int number = 0);
QByteArray downloadedData() const;
void launchNewDownload(QUrl url);
QByteArray m_DownloadedData;
QNetworkReply* reply;
static QNetworkAccessManager *m_WebCtrl;
signals:
void downloaded();
private slots:
void fileDownloaded(QNetworkReply* pReply);
};
And here is the .cpp file :
QNetworkAccessManager* FileDownloader::m_WebCtrl = nullptr;
FileDownloader::FileDownloader(QUrl url, QObject *parent) :
QObject(parent)
{
if (m_WebCtrl == nullptr) {
m_WebCtrl = new QNetworkAccessManager(this);
}
connect(m_WebCtrl, SIGNAL (finished(QNetworkReply*)),this, SLOT (fileDownloaded(QNetworkReply*)));
launchNewDownload(url);
}
void FileDownloader::launchNewDownload(QUrl url) {
QNetworkRequest request(url);
this->reply = m_WebCtrl->get(request);
}
void FileDownloader::fileDownloaded(QNetworkReply* pReply) {
m_DownloadedData = pReply->readAll();
//emit a signal
pReply->deleteLater();
emit downloaded();
}
QByteArray FileDownloader::downloadedData() const {
return m_DownloadedData;
}
The issue is "QThread::start: Failed to create thread ()" when reaching about the 500th download. I tried to limit the number of downloads which run at the same time - but I always get the same issue. Besides, I tried to delete every downloader when finishing its task - it did nothing else than crashing the program ;)
I think that it is coming from the number of threads allowed for an only process, but I'm not able to solve it !
Does anyone have an idea that could help me ?
Thank you !
QNetworkAccessManager::finished signal is documented to be emitted whenever a pending network reply is finished.
This means that if the QNetworkAccessManager is used to run multiple requests at a time (and this is perfectly normal usage). finished signal will be emitted once for every request. Since you have a shared instance of QNetworkAccessManager between your FileDownloader objects, the finished signal gets emitted for every get call you have made. So, all the FileDownloader objects get a finished signal as soon as the first FileDownloader finishes downloading.
Instead of using QNetworkAccessManager::finished, you can use QNetworkReply::finished to avoid mixing up signals. Here is an example implementation:
#include <QtNetwork>
#include <QtWidgets>
class FileDownloader : public QObject
{
Q_OBJECT
//using constructor injection instead of a static QNetworkAccessManager pointer
//This allows to share the same QNetworkAccessManager
//object with other classes utilizing network access
QNetworkAccessManager* m_nam;
QNetworkReply* m_reply;
QByteArray m_downloadedData;
public:
explicit FileDownloader(QUrl imageUrl, QNetworkAccessManager* nam,
QObject* parent= nullptr)
:QObject(parent), m_nam(nam)
{
QNetworkRequest request(imageUrl);
m_reply = m_nam->get(request);
connect(m_reply, &QNetworkReply::finished, this, &FileDownloader::fileDownloaded);
}
~FileDownloader() = default;
QByteArray downloadedData()const{return m_downloadedData;}
signals:
void downloaded();
private slots:
void fileDownloaded(){
m_downloadedData= m_reply->readAll();
m_reply->deleteLater();
emit downloaded();
}
};
//sample usage
int main(int argc, char* argv[]){
QApplication a(argc, argv);
QNetworkAccessManager nam;
FileDownloader fileDownloader(QUrl("http://i.imgur.com/Rt8fqpt.png"), &nam);
QLabel label;
label.setAlignment(Qt::AlignCenter);
label.setText("Downloading. . .");
label.setMinimumSize(640, 480);
label.show();
QObject::connect(&fileDownloader, &FileDownloader::downloaded, [&]{
QPixmap pixmap;
pixmap.loadFromData(fileDownloader.downloadedData());
label.setPixmap(pixmap);
});
return a.exec();
}
#include "main.moc"
If you are using this method to download large files, consider having a look at this question.
One solution could be to uses a QThreadPool. You simply feed it tasks (QRunnable) and it will handle the number of threads and the task queue for you.
However in your case this is not perfect because you will be limiting the number of simultaneous downloads to the number of threads created by QThreadPool (generally the number of CPU core you have).
To overcome this you will have to handle the QThread yourself and not use QThreadPool. You would create a small number of thread (see QThread::idealThreadCount()) and run multiple FileDownloader on each QThread.
I created an application in which I would like to add a loading screen when the application is opening a project because the loading of the project can be long and sometimes, the gui blocks so the user can think there is a crash.
So I tried with QThread, reading doc and "solved" examples on this forum but nothing to do, I can't make it work.
I have a MainWindow class which deals with GUI and this class is the one I create in the main function :
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}
Then I have :
mainwindow.h
class MyThread;
class MainWindow : public QMainWindow
{
Q_OBJECT
...
private :
Controller *controller;//inherits from QObject and loads the project
QList<MyThread*> threads;
public slots :
void animateLoadingScreen(int inValue);
}
mainwindow.cpp
MainWindow::MainWindow(...)
{
controller=new Controller(...);
threads.append(new MyThread(30, this));
connect(threads[0], SIGNAL(valueChanged(int)), this, SLOT(animateLoadingScreen(int)));
}
void MainWindow::animateLoadingScreen(int inValue)
{
cout<<"MainWindow::animateLoadingScreen"<<endl;
widgetLoadingScreen->updateValue(inValue);//to update the animation
}
void MainWindow::openProject()
{
widgetLoadingScreen->show()://a widget containing a spinner for example
threads[0]->start();//I want to launch the other thread here
controller->openProject();
threads[0]->exit(0);//end of thread so end of loading screen
}
MyThread.h
class MyThread : public QThread
{
Q_OBJECT;
public:
explicit MyThread(int interval, QObject* parent = 0);
~MyThread();
signals:
void valueChanged(int);
private slots:
void count(void);
protected:
void run(void);
private:
int i;
int inc;
int intvl;
QTimer* timer;
};
MyThread.cpp
MyThread::MyThread(int interval, QObject* parent): QThread(parent), i(0), inc(-1), intvl(interval), timer(0)
{
}
void MyThread::run(void)
{
if(timer == 0)
{
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(count()));
}
timer->start(intvl);
exec();
}
void MyThread::count(void)
{
if(i >= 100 || i <= 0)
inc = -inc;
i += inc;
emit valueChanged(i);
}
When I execute the app, and click on open button which launches MainWindow::openProject(), I get :
QObject: Cannot create children for a parent that is in a different thread.
(Parent is MyThread(0x5463930), parent's thread is QThread(0x3cd1f80), current thread is MyThread(0x5463930)
MainWindow::animateLoadingScreen
MainWindow::animateLoadingScreen
....
MainWindow::animateLoadingScreen
MainWindow::animateLoadingScreen
(and here the controller outputs. and no MainWindow::animateLoadingScreen anymore so the widget loading screen is never animated during the opening of the project)
So what do I have to do, what do I have to put in MyThread class, how to link its signal to MainWindow to update the loading screen. And I think that there may be a problem with widgetLoadingScreen which is created in MainWindow so if MainWindow is blocked beacause of the opening, the widgetLoadingScreen can't be updated since it is in the thread of MainWindow which handles the GUI ?!
I read :
http://www.qtcentre.org/wiki/index.php?title=Updating_GUI_from_QThread
but with that one, I got error message at runtime, it's the one I use in the code I give above
QObject: Cannot create children for a parent that is in a different thread.
(Parent is MyThread(0x41938e0), parent's thread is QThread(0x1221f80), current thread is MyThread(0x41938e0)
I tried that too :
How to emit cross-thread signal in Qt?
but, even if I don't have the error message at runtime, it's the same for the animation which is not updated.
I am completely lost, and I don't think it's something difficult to do to have a loading screen in a thread while the main thread is opening a project?!
Qt has a QSplashScreen class which you could use for a loading screen.
Besides this, one of the problems you have is due to thread affinity (the thread in which an object is running) and the fact that you've decided to inherit from QThread.
In my opinion, QThread has a misleading name. It's more of a thread controller and unless you want to change how Qt handles threads, you really shouldn't inherit from it and many will tell you that "You're doing it Wrong!"
By inheriting QThread, your instance of MyThread is running on the main thread. However, when a call to exec() is made, it starts the event loop for the new thread and all its children, which includes the QTimer, and tries to move it to the new thread.
The correct way to solve this is not to inherit from QThread, but to create a worker object, derived from QObject and move it to the new thread. You can read about how to 'Really Truly Use QThread' here.
1st problem - runtime error with QTimer
Problem is in void MyThread::run(void), line timer = new QTimer(this);. The thread instance is created in (and so owned by) different (main) thread then it represents. For this reason, you cannot use thread as parent for object created inside the thread. In your case, solution is simple - create the timer on stack.
Example:
void MyThread::run(void)
{
QTimer timer;
connect(&timer, SIGNAL(timeout()), this, SLOT(count()));
timer.start(intvl);
// Following method start event loop which makes sure that timer
// will exists. When this method ends, timer will be automatically
// destroyed and thread ends.
exec();
}
2nd problem - GUI not updating
Qt requires the GUI to be created and displayed from main application thread. This means that blocking main thread with big operation blocks whole GUI. There are only 2 possible solutions:
Move the heavy work to other (loading) thread. This is best solution and I believe it's worth the effort (I'm aware you wrote that this would be problematic).
During the heavy operation, call regularly QCoreApplication::processEvents() - each time you call this, events will be processed, which includes calling slots, key and mouse events, GUI redraw etc. The more often you call this, the more responsive GUI will be. This is simpler to implement (just put one line all over the code), but it's quite ugly and if the operation blocks on loading a file, the GUI will freeze for some time. That means that responsiveness of your GUI depends on interval between calls. (But if you call it too often, you will slow down the loading progress.) This technique is discouraged and it's best to avoid it...
The way I will do it based on the default example on Qthread Page:
Break the big controller->openProject(); such that it updates a variable
provide access to that variable using a signal ( like statusChanged(int)).
Do what you need to do once the signal is triggered.
The code looks like
class Worker : public QObject
{
Q_OBJECT
QThread workerThread;
private:
int status; //
bool hasworktoDo();
void doSmallWork();
public slots:
void doWork() {
while(hasworktoDo())
{
doSmallWork(); // fragments of controller->openProject();
++status; //previously set to 0
emit statusChanged(status);
}
emit resultReady(result);
}
signals:
void resultReady(const QString &result);
void statusChanged(int value);
};
class Controller : public QObject
{
Q_OBJECT
QThread workerThread;
public:
Controller() {
Worker *worker = new Worker;
worker->moveToThread(&workerThread);
connect(workerThread, SIGNAL(statusChanged(int)), this, SLOT(updateStatus(int)));
connect(workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()));
connect(this, SIGNAL(operate()), worker, SLOT(doWork()));
connect(worker, SIGNAL(resultReady(QString)), this, SLOT(handleResults(QString)));
workerThread.start();
}
~Controller() {
workerThread.quit();
workerThread.wait();
}
public slots:
void handleResults(const QString &);
void updateStatus(int value)
{
int status = value;
//now you have what to use to update the ui
}
signals:
void operate(); //
};
If you have trouble breaking the openProject operations in small parts, it just mean it is pointless to say on the UI that you are at 50%... Just say Loading... and make the code simpler. Note that you don't need a timer in my case, as the worker sends regular updates
This question already has answers here:
QThread and QTimer
(4 answers)
Closed 8 years ago.
I have some very time consuming tasks to execute in a GUI application, and I want them to be threaded so it won't freeze my GUI..
To do so, I created a thread, and started a timer. I connected the timeout() method from my timer to the time-consuming function I want to paralellize, in the "run" method of my thread, but when the signal is called, the time-consuming function is called in the main thread instead of the one I created.
Here's my code, simplified for the example:
void MyThread::run()
{
m_pTimer = new QTimer()
connect(m_pTimer, SIGNAL(timeout()), this, SLOT(timeConsumingMethod()));
m_pTimer->start(x);
}
I printed the value of the static method QThread::currentThread() in "timeConsumingMethod", in MyThread::run() and in my main, and its value is the same as the one in my main.
How can I make my function run in the separated thread? And more important why is my code wrong?
"You’re doing it wrong." :)
try this:
myworker.h
#include ...
class MyWorker : public QObject {
Q_OBJECT
public:
explicit MyWorker(QObject* parent = 0);
public slots:
void timeConsumingMethod();
}
myworker.cpp
#include "myworker.h"
#include ...
MyWorker::MyWorker(QObject* parent) :
QObject(parent)
{
/*
...
*/
}
void MyWorker::timeConsumingMethod() {
/*
...
*/
}
code
/*...*/
MyWorker* worker = new MyWorker();
QThread* workerThread = new QThread();
QTimer* timer = new QTimer();
worker->moveToThread(workerThread);
worker->connect(timer, SIGNAL(timeout()), SLOT(timeConsumingMethod()));
// don't forget proper obj deletion
// not the best way, but...
worker->connect(workerThread, SIGNAL(destroyed()), SLOT(deleteLater());
workerThread->start();
timer->start(x);
in that case worker will "live" in workerThread. QT SIGNAL-SLOT mechanism supports connection between objects in different threads.
that approach much better than "procedural way" by reimplementing run() method and QThread inheritance
worker works, QThread controls thread
source: http://qt-project.org/wiki/Threads_Events_QObjects