标签: qthread

在调用与QThread :: finished()信号关联的所有插槽后,QThread :: wait()是否返回(即解除阻塞执行)？

提前致谢.

我试图在一个单独的线程中执行一些工作,并在工作完成后停止该线程.

我已经建立了这样的连接

thread.connect( workerClass, SIGNAL( finished() ), SLOT( quit() ) );

但是当我发出finished()信号时,从不调用quit()槽.命令行不显示与失败连接相关的任何警告.

我创建了一个简单的测试项目来缩小问题范围,我得到了同样的行为:

TestClass.h:

#ifndef TESTCLASS_H
#define TESTCLASS_H
class TestClass : public QObject
{
    Q_OBJECT
public:
    TestClass() { }
signals:
    void finished();
public slots:
    void doWork();
}
#endif // TESTCLASS_H

TestClass.cpp:

#include "TestClass.h"
#include <QtCore/QDebug>
void TestClass::doWork()
{
    qDebug() << "Starting";
    for( long i = 0; i < 1000000000; i++ );
    qDebug() << "Done";
    emit finished();
};

和main.cpp:

#include <QtCore/QCoreApplication>
#include <QtCore/QThread>
#include "TestClass.h"

int main( int argc, char* argv[] …

相当新的线程,我有这个线程在它们之间共享的QList.它们都有自己可以处理的空间,GUI(模型/视图)不断访问此列表.然后我得到这个指向QDataList.size()的崩溃.调试并没有真正帮助我,因为我从未遇到过这个问题,如果我单步执行代码,当我正在尝试qList崩溃时,没有可用的信息.

所以,我的问题是:是否有可能获得Qlists大小并同时读取对象？列表中的对象是线程安全的,不能同时由不同的线程读/写.

获取"0xC0000005:访问冲突读取位置0xfeeefefa".它指向我:qlist.h中的inline int size()const

我走过调用堆栈,发现这个:

QtCored4.dll!QListData::size()  Line 98 + 0x11 bytes    C++
QtNetworkd4.dll!QList<enum QNetworkReplyImplPrivate::InternalNotifications>::size()  Line 137 + 0x10 bytes  C++
QtNetworkd4.dll!QNetworkReplyImplPrivate::resumeNotificationHandling()  Line 444 + 0xe bytes    C++
QtNetworkd4.dll!QNetworkReplyImplPrivate::finished()  Line 797  C++
QtNetworkd4.dll!QNetworkAccessBackend::finished()  Line 313 C++
QtNetworkd4.dll!QNetworkAccessHttpBackend::replyFinished()  Line 739    C++
QtNetworkd4.dll!QNetworkAccessHttpBackend::qt_static_metacall(QObject * _o, QMetaObject::Call _c, int _id, void * * _a)  Line 86 + 0x8 bytes    C++
QtCored4.dll!QMetaCallEvent::placeMetaCall(QObject * object)  Line 525 + 0x1d bytes C++
QtCored4.dll!QObject::event(QEvent * e)  Line 1195 + 0x14 bytes C++
QtGuid4.dll!QApplicationPrivate::notify_helper(QObject * receiver, QEvent * …

我在QT尝试多线程服务器.但是,我不断收到这个恼人的错误:

错误:不是信号或插槽声明(第21行)

这是我的代码:

mythread.h

#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QThread>
#include <QTcpSocket>

class MyThread : public QThread
{
    Q_OBJECT
public:
    explicit MyThread(int ID, QObject *parent = 0);
    void run();
signals:
    void error(QTcpSocket::SocketError socketerror);

public slots:
    void readyRead();
    void disconnected();

public slots:
    QTcpSocket *socket;
    int socketDescriptor; //Socket ID Number

};

#endif // MYTHREAD_H

我有一个MyClass继承自的子类QThread.

我用这个MainWindow实例的父代创建它(这个):

mMyClass = new MyClass("some_value", 1, 5L, this);

我对Qt如何处理对象删除的理解是,QObject当父项被删除时,每个父母都会被删除.

如果我的程序完成,我会收到警告 QThread: Destroyed while thread is still running

我怎样才能解决这个问题？我在解构器中使用以下代码尝试了它MainWindow.不幸的是它无法正常工作:

if (mMyClass != 0 && mMyClass->isRunning()) {
    mMyClass->deleteLater();
    mMyClass->quit();
    mMyClass->wait();
}

我有一个主要的pyqt程序，需要运行带有参数的外部程序。我想将QDialog用作一种状态监视器，它将在执行外部程序时捕获外部程序的标准输出，并将其显示在QDialog内的文本框中。我有以下状态监视器代码：

class ProgressInfo(QtGui.QDialog):
    def __init__(self, cmd, args, parent=None):
        #super(self).__init__(parent)
        QDialog.__init__(self)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.cmd = cmd
        self.args = args
        self.keepGoing = True
        layout = QFormLayout()
        layout.setContentsMargins(10, 10, 10, 10)
        self.output = QtGui.QTextEdit()
        layout.addRow(self.output)
        layout.addRow(self.ui.buttonBox)
        self.setLayout(layout)

        self.ext_process = QtCore.QProcess(self)
        #self.ext_process.waitForFinished(-1)
        #self.ext_process.waitForStarted()
        #self.ext_process.readyRead.connect(self.dataReady)
        self.ext_process.started.connect(self.open)
        self.ext_process.readyReadStandardOutput.connect(self.dataReady)
        self.ext_process.finished.connect(self.onProcessFinished)
        self.ext_process.start(self.cmd, self.args)

    def dataReady(self):
        cursor = self.output.textCursor()
        cursor.movePosition(cursor.End)
        cursor.insertText(str(self.ext_process.readAll()))
        self.output.ensureCursorVisible()

    def onProcessFinished(self):
        cursor = self.output.textCursor()
        cursor.movePosition(cursor.End)
        #cursor.insertText(str(self.ext_process.readAll()))
        cursor.insertText(str(self.ext_process.readAllStandardOutput()))
        self.output.ensureCursorVisible()

然后，我将使用以下命令实例化该命令：

prog='C:/Program Files (x86)/My Program/Execute.exe'
margs=['D:/Data/Input1.txt', 'D:/Data/Input2.txt']
status = ProgressInfo(prog, margs, self)

到目前为止，这还没有奏效。

问题1：仅在取消注释waitForFinished（-1）行之后，外部程序才会运行。

问题2。QDialog框仅在一瞬间打开，然后消失。

问题3.显然，没有显示正在运行的程序的任何异常。 …

我QThread在我的应用程序中使用了一些.

我的对象在不同的​​线程中"活动"(它们的所有者线程为Qt意味着它是不同的)并使用带有排队连接的信号/槽来进行通信.

现在,我有这个问题:

• 对象"A"生活在QThread"A"中
• 对象"B"生活在QThread"B"中
• 桂生活在"主线"

然后 :

• 对象"A" B::foo从其自己的线程"A" 调用"B"实例上的方法
• B::foo使用互斥锁保护此方法共享的资源,这里没有问题B::foo从线程"A"执行
• 在B::foo方法内部,对象"B"发出信号barSignal

我对他的配置有一些疑问:

• 从不是"B"所有者的线程发出对象"B"的信号是否安全QThread？

• 用于Qt::AutoConnection在生活在"Qt主线程"中的GUI对象中接收此信号是否安全？

• Qt::AutoConnection在生活在它自己的QThread"C" 中的对象"C"中使用a 接收此信号是否安全？

我的测试往往对一切都说"是".通过阅读Qt emit代码,似乎没问题.但它没有在Qt文档中找到任何关于" 从一个不是发射器的所有者线程的线程发出信号 "的内容.

我的问题是两部分:

1. 是mainWindow在运行main()的线程之外的线程中生成的？
2. mainWindow当main()返回时,如何不立即超出范围？

在下面的示例中,创建一个窗口,显示,并且main几乎立即返回.

main.cpp中

#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H …

在main()即主线程中创建了一个QThread.将一个worker类移动到新线程.该线程执行worker类的'StartThread'方法.

工人线程:

//header file
class Worker : public QObject
{
    Q_OBJECT
public:
    Worker(QThread* thread);

public slots:
    void StartThread(); 
    void EndThread();

private:
    QThread* m_pCurrentThread;
};


// source file
#include "QDebug"
#include "QThread"
#include "worker.h"

Worker::Worker(QThread* thread)
{
m_pCurrentThread = thread;
}

void Worker::StartThread()
{
    qDebug() << " StartThread";

    while(true)
    {
        QThread::msleep(1000);
        qDebug() << " thread running";
        static int count = 0;
        count++;
        if(count == 10)
        {            
            break;
        }
        if(m_pCurrentThread->isInterruptionRequested())
        {
            qDebug() << " is interrupt requested";
            // Option 3:  
            m_pCurrentThread->exit();               
        } …

我试图弄清楚为什么这个代码崩溃,如果我尝试完成第二次运行线程.

我第一次单击"开始5个线程"它运行得很好并完成.但是,如果我再次点击它.整个程序崩溃,我得到QThread:当线程仍在运行时销毁错误

此代码可在网上找到.我想从中吸取教训.

import time
import sys

from PyQt5.QtCore import QObject, QThread, pyqtSignal, pyqtSlot
from PyQt5.QtWidgets import QApplication, QPushButton, QTextEdit, QVBoxLayout, QWidget


def trap_exc_during_debug(*args):
    # when app raises uncaught exception, print info
    print(args)


# install exception hook: without this, uncaught exception would cause application to exit
sys.excepthook = trap_exc_during_debug


class Worker(QObject):
    """
    Must derive from QObject in order to emit signals, connect slots to other signals, and operate in a QThread.
    """

    sig_step = pyqtSignal(int, str)  # worker id, step …