Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. International
  3. German
  4. QThread richtig einsetzen?
Forum Updated to NodeBB v4.3 + New Features

QThread richtig einsetzen?

Scheduled Pinned Locked Moved Solved German
39 Posts 3 Posters 17.8k Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • G Offline
    G Offline
    Galilio
    wrote on last edited by
    #1

    Hallo zusammen,

    Wie ist einen Thread mit Mutex einzusetzen?
    Welche varianten der Thread Benutzung ist zu empfehlen?
    Wie ist der Thread richtig einzusetzen?

    Es sind nur fragen nach fragen und wäre sehr dankar, wenn mir jemenden das einbisschen erklärt.

    Danke in voraus

    J.HilkJ C 2 Replies Last reply
    0
    • G Offline
      G Offline
      Galilio
      wrote on last edited by Galilio
      #29

      Guten morgen zusammen
      Problem wurde gelöst.
      ich habe es immer den falschen Thread benutzt und dazu versuche ich ihm zu löschen.
      danke
      @J-Hilk

      1 Reply Last reply
      1
      • G Galilio

        Hallo zusammen,

        Wie ist einen Thread mit Mutex einzusetzen?
        Welche varianten der Thread Benutzung ist zu empfehlen?
        Wie ist der Thread richtig einzusetzen?

        Es sind nur fragen nach fragen und wäre sehr dankar, wenn mir jemenden das einbisschen erklärt.

        Danke in voraus

        J.HilkJ Offline
        J.HilkJ Offline
        J.Hilk
        Moderators
        wrote on last edited by
        #2

        @Galilio
        hi,

        QThread ist ein verwirrendes Thema, zumal die offizielle Doku für Jahre unglücklich formuliert war. Das ist mittlerweile angepasst worden. In dem Detailed Description Teil findest du ein gutes und richtiges Beispiel wie man QThread + worker verwendet.

        Hier eine kurzer, und grober, Überblick.

        Im Prinzip stehen dir 2 Möglichkeiten zur Verfügung:
        QThread und QtConcurrent

        Wenn du zum Beispiel nur eine Funktion hast die eine Zahl berechnet, und du willst diese Berechnung laufen lassen ohne das GUI zu blocken, QtConcurrent ist vermutlich die bessere Wahl.

        Ansonsten empfehle ich diesen Block:how to really truly use qthreads

        QMutex Class hilft dir zu verhindern das 2 parallel laufende Threads gleichzeitig auf den gleichen Speicher zugreifen.
        In 90% der Fälle, wenn man QThread + Signal/SLOTS oder QtConcurrent verwendet, wird man niemals aktive QMutex anfassen müssen.


        Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


        Q: What's that?
        A: It's blue light.
        Q: What does it do?
        A: It turns blue.

        1 Reply Last reply
        0
        • G Offline
          G Offline
          Galilio
          wrote on last edited by
          #3

          Hallo,

          ich bin einfach verwirrt .
          Ich kriege das vorgeschlagene Beispiel nichts zum laufen.

          Hast du bitte für mich einen fertigen Beispiel mit denen ich starten kann?

          Sorry

          J.HilkJ 1 Reply Last reply
          0
          • G Galilio

            Hallo,

            ich bin einfach verwirrt .
            Ich kriege das vorgeschlagene Beispiel nichts zum laufen.

            Hast du bitte für mich einen fertigen Beispiel mit denen ich starten kann?

            Sorry

            J.HilkJ Offline
            J.HilkJ Offline
            J.Hilk
            Moderators
            wrote on last edited by
            #4

            @Galilio
            Wenn ich heute von der Arbeit heimkomme erstelle ich ein kleines Beispiel und lade es auf github


            Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


            Q: What's that?
            A: It's blue light.
            Q: What does it do?
            A: It turns blue.

            G 1 Reply Last reply
            0
            • J.HilkJ J.Hilk

              @Galilio
              Wenn ich heute von der Arbeit heimkomme erstelle ich ein kleines Beispiel und lade es auf github

              G Offline
              G Offline
              Galilio
              wrote on last edited by
              #5

              @J.Hilk

              Super vielen dank

              J.HilkJ 1 Reply Last reply
              0
              • G Galilio

                Hallo zusammen,

                Wie ist einen Thread mit Mutex einzusetzen?
                Welche varianten der Thread Benutzung ist zu empfehlen?
                Wie ist der Thread richtig einzusetzen?

                Es sind nur fragen nach fragen und wäre sehr dankar, wenn mir jemenden das einbisschen erklärt.

                Danke in voraus

                C Offline
                C Offline
                c64zottel
                wrote on last edited by
                #6

                @Galilio Qt-creator liefert Dir einige Beispiele zu QThread. Einfach unter Welcome den Menupunkt Examples (evt. bei Dir Beispiele auswaehlen und dann nach thread suchen.

                Ich habe gerade mal das Queued Custom Type angeschaut, das sieht ganz gut aus: 4 Dateien.

                Den Artikel der oben verlinkt wurde finde ich nicht so gut. Die Lady erklaert zwar ein Beispiel aber erlaeutert keinerlei Vorzuege von ihrer Methode.

                So wie ich das sehen gibt es 2 verschiedene Szenarien:

                • Ich habe einen Thread den ich immer neben meiner Anwendung laufen lasse. Dann leite ich von QThread ab.
                • Habe ich worker und moechte meine arbeit einfach aus der GUI verlgen, dann nutze ich QThread wie im Artikel (Oder auch QtConcurrent)

                Das ist jetzt eher so gefuehlt, gerne lese ich aber ueber die Argumente dafuer und dagegen.

                1 Reply Last reply
                0
                • G Galilio

                  @J.Hilk

                  Super vielen dank

                  J.HilkJ Offline
                  J.HilkJ Offline
                  J.Hilk
                  Moderators
                  wrote on last edited by
                  #7

                  @Galilio
                  Hier der Git Link

                  QtConcurrent und QThread Beispiel


                  Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


                  Q: What's that?
                  A: It's blue light.
                  Q: What does it do?
                  A: It turns blue.

                  G 1 Reply Last reply
                  0
                  • J.HilkJ J.Hilk

                    @Galilio
                    Hier der Git Link

                    QtConcurrent und QThread Beispiel

                    G Offline
                    G Offline
                    Galilio
                    wrote on last edited by
                    #8

                    @J.Hilk

                    Vielen Dank.
                    Ich bin dabei deine Example zu studieren.
                    Danke noch mal

                    G 1 Reply Last reply
                    0
                    • G Galilio

                      @J.Hilk

                      Vielen Dank.
                      Ich bin dabei deine Example zu studieren.
                      Danke noch mal

                      G Offline
                      G Offline
                      Galilio
                      wrote on last edited by
                      #9
                      This post is deleted!
                      G 1 Reply Last reply
                      0
                      • G Galilio

                        This post is deleted!

                        G Offline
                        G Offline
                        Galilio
                        wrote on last edited by
                        #10

                        @Galilio said in QThread richtig einsetzen?:

                        Wenn ich folgenden habe:

                        Header File:

                        class QTcpSocket;
                        
                        class CAgilentLan : public QThread
                        {
                        
                        public:
                        
                        	typedef enum 
                        	{
                        		enRspTimeout = -2, 
                        		enRspOffline,
                        		enRspOK,
                        		enRspError
                        	} t_enRspType ;
                        
                        
                        	CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p=false, bool boDebug_p=false);
                        	~CAgilentLan();
                        
                        	// High-Level Funktionen
                        	QByteArray ExecuteGetScreenshot(void);
                        	void ExecuteSaveScreenshot(QString &strPathFileName_p, const char *strFormat_p);
                        	void ExecuteSettingsSave(unsigned char ucRegisterNo_p);
                        	void ExecuteSettingsRecall(unsigned char ucRegisterNo_p);
                        	double ExecuteQuickMeasure(unsigned char ucChannel_p, char *pchType_p);
                        	double ExecuteStatMeasure(char *pchType_p, bool boTrigger_p);
                        	void ExecuteResetMeasurementStatistics(void);
                        
                        	bool Open(const QString &strIpAdress_p, const int iTimeout_p);
                        	bool Close(const int iTimeout_p);
                        	t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                        	QByteArray GetLastResponse(void);
                        
                        	t_enRspType ExecuteSimulated(const char *strCmd_p);
                        	QString GetAgilentIdentifikation();
                        
                        	...
                        
                        protected:
                        	void run();
                        
                        private:
                        	bool m_boDebug;
                        	bool m_boSimulate;
                        	
                        	QMutex m_MtxProcess;
                        	QMutex m_MtxResponse;
                        
                        	QWaitCondition m_WaitCondProcess;
                        	QByteArray m_ByteArrayWrite;
                        	QByteArray m_ByteArrayRead;
                        
                        	QByteArray m_IDN_AgilentIdentification;
                        	
                        	//Hilfsvariable
                        	double m_SDDevPeriodeA ;
                        	double m_SDDevDCA;
                        	double m_SDDevDCB;
                        	double m_SDDevWidthZ;
                        
                        	double m_OZiSDDevPeriodeA;
                        	double m_OZiSDDevDCA;
                        	double m_OZiSDDevDCB;
                        	double m_OZiSDDevWidthZ;
                        
                        	double m_OZiMeanPeriodeA;
                        	double m_OZiMeanDCA;
                        	double m_OZiMeanDCB;
                        	double m_OZiMeanWidthZ;
                        	
                        	QByteArray m_ByteSTDD;
                        	QByteArray m_ByteMean;
                        	QStringList m_ListSTDDev;
                        	QStringList m_ListMean;
                        
                        	QTcpSocket *m_pTcpSctCtrl;
                        	
                        	QString m_strCtrlIP;
                        	int m_iTimeoutClose;
                        	int m_iTimeout;
                        	int m_iResponseDelayed;
                        	int m_iWaitResponse;
                        
                        	t_enRspType m_enRetVal;
                        };
                        
                        

                        cpp File:

                        CAgilentLan::CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p, bool boDebug_p):m_SDDevPeriodeA(0), m_SDDevDCA(0),m_SDDevDCB(0),m_SDDevWidthZ(0)
                        {
                        //	boSimulate_p = false;
                        	
                        	m_boDebug = boDebug_p;
                        	m_boSimulate = boSimulate_p;
                        
                        	m_enRetVal = enRspOffline;
                        	m_strCtrlIP = QString("");
                        	m_iTimeout = 0;
                        	m_iTimeoutClose = iTimeout_p;
                        	if (this->Execute("CreateObject", 0, 0, 0) != enRspOK)
                        	{
                        		throw(QString("Error AgilentLan.CPP/Constructor TcpSocket Create memory error"));
                        	}
                        
                        	this->Open(strIpAdress_p, iTimeout_p);
                        }
                        
                        CAgilentLan::~CAgilentLan()
                        {
                        	while(isRunning());
                        
                        	this->Close(m_iTimeoutClose);
                        
                        	while(isRunning());
                        	
                        	if (this->Execute("DeleteObject", 0, 0, 0) != enRspOK)
                        	{
                        		throw(QString("Error AgilentLan.CPP/Destructor TcpSocket Delete memory error"));
                        	}
                        
                        	
                        	while(isRunning());
                        }
                        bool CAgilentLan::Open(const QString &strCtrlIP_p, const int iTimeout_p)
                        {
                        	bool boRet_l = true;
                        
                        	m_strCtrlIP = strCtrlIP_p;
                        		
                        	if (this->Execute("OpenConnection", 0, iTimeout_p, 0) != enRspOK)
                        	{
                        		throw(QString("Error AgilentLan.CPP/Open TcpSocket Open Connection error"));
                        	}
                        	
                        	if (m_boDebug)
                        	{
                        		throw(QString("Tcp Socket is open"));
                        	}
                        
                        	return boRet_l;
                        }
                        
                        bool CAgilentLan::Close(const int iTimeout_p)
                        {
                        	bool boRet_l = true;
                        
                        	while(isRunning());
                        
                        	if (this->Execute("CloseConnection", 0, iTimeout_p, 0) != enRspOK)
                        	{
                        		throw(QString("Error AgilentLan.CPP/Close Connection error"));
                        	}
                        	
                        	if (m_boDebug)
                        	{
                        		throw(QString("Tcp Socket is closed"));
                        	}
                        
                        	while(isRunning());
                        
                        	return boRet_l;
                        }
                        
                        
                        CAgilentLan::t_enRspType CAgilentLan::Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p)
                        {
                        	CAgilentLan::t_enRspType enRetVal_l = enRspOffline;
                        
                        	if (!isRunning())
                        	{
                        		m_ByteArrayRead.clear();
                        
                        		m_ByteArrayWrite.clear();
                        		m_ByteArrayWrite.append(strCmd_p);
                        		
                        		m_iWaitResponse = iWaitResponse_p;
                        		m_iTimeout = iTimeout_p;
                        		m_iResponseDelayed = iRspDelayed_p;
                        
                        		start();
                        
                        		m_MtxProcess.lock();
                        		m_WaitCondProcess.wait(&m_MtxProcess,-1);
                        		m_MtxProcess.unlock();
                        	
                        		enRetVal_l = this->m_enRetVal;
                        	}
                        	else
                        	{
                        		enRetVal_l = enRspError;
                        	}
                        	
                        	while(isRunning());
                        	
                        	return enRetVal_l;
                        }
                        
                        QByteArray CAgilentLan::GetLastResponse(void)
                        {
                        	QByteArray ay_l;
                        
                        	m_MtxResponse.lock();
                        	ay_l = m_ByteArrayRead;
                        	m_MtxResponse.unlock();
                        
                        	return ay_l;
                        }
                        void CAgilentLan::run()
                        {
                        	bool boRun_l = true;
                        	bool boSent_l = false;
                        
                        	const char *pStrCmd_l = NULL;
                        	const char *pStrRsp_l = NULL;
                        
                        	m_enRetVal = enRspError;
                        
                        	if (strcmp(m_ByteArrayWrite.data(),"CreateObject")==0)
                        	{
                        		if (this->m_boSimulate == true)
                        		{
                        			m_enRetVal = enRspOK;
                        		}
                        		else
                        		{
                        			m_pTcpSctCtrl = (QTcpSocket *)new QTcpSocket;
                        			if (m_pTcpSctCtrl != NULL)
                        			{
                        				m_enRetVal = enRspOK;
                        			}
                        		}
                        
                        		boRun_l = false;
                        	}
                        
                        	if (strcmp(m_ByteArrayWrite.data(),"DeleteObject")==0)
                        	{
                        		if (this->m_boSimulate == true)
                        		{
                        		}
                        		else
                        		{
                        			if (m_pTcpSctCtrl != NULL)
                        			{
                        				delete m_pTcpSctCtrl;
                        			}
                        		}
                        
                        		m_enRetVal = enRspOK;
                        		boRun_l = false;
                        	}
                        
                        	if (strcmp(m_ByteArrayWrite.data(),"OpenConnection")==0)
                        	{
                        		if (this->m_boSimulate == true)
                        		{
                        			m_enRetVal = enRspOK;
                        		}
                        		else
                        		{
                        			m_pTcpSctCtrl->connectToHost(m_strCtrlIP,5025);
                        			if (m_pTcpSctCtrl->waitForConnected(m_iTimeout) == true)
                        			{
                        				m_enRetVal = enRspOK;
                        			}
                        		}
                        		
                        		boRun_l = false;
                        	}
                        
                        	if (strcmp(m_ByteArrayWrite.data(),"CloseConnection")==0)
                        	{
                        		if (this->m_boSimulate == true)
                        		{
                        			m_enRetVal = enRspOK;
                        		}
                        		else
                        		{
                        			m_pTcpSctCtrl->disconnectFromHost();
                        			if ((m_pTcpSctCtrl->state() == QAbstractSocket::UnconnectedState) || (m_pTcpSctCtrl->waitForDisconnected(m_iTimeout)))
                        			{
                        				m_enRetVal = enRspOK;
                        			}
                        		}
                        		
                        		boRun_l = false;
                        	}
                        
                        	int iTimeout_l = m_iTimeout;
                        	
                        	while (boRun_l && (!this->m_boSimulate))
                        	{
                         		if (boSent_l == false)
                        		{
                        			boSent_l = true;
                        			// Kommando absetzen
                        			m_pTcpSctCtrl->write(m_ByteArrayWrite.data(),m_ByteArrayWrite.size());
                        			// Auf Antwort warten
                        			if (m_iWaitResponse >= 0)
                        			{
                        				QThread::msleep(m_iWaitResponse);
                        			}
                        			else
                        			{
                        				boRun_l = false;
                        			}
                        		}
                        		
                        		// Anwort auf Kommando abwarten	
                        		if ((m_pTcpSctCtrl->bytesAvailable() > 0) && (boRun_l == true))
                        		{
                        			m_MtxResponse.lock();
                        
                        			m_ByteArrayRead.append(m_pTcpSctCtrl->readAll());
                        			
                        			if (m_boDebug)
                        			{
                        				throw(QString(m_ByteArrayRead.data()));
                        			}
                        
                        			m_MtxResponse.unlock();
                        
                        			iTimeout_l = m_iTimeout;
                        //			iTimeout_l = m_iWaitResponse;
                        		}
                        		else
                        		{
                        			if (m_pTcpSctCtrl->waitForReadyRead(iTimeout_l) == false)
                        			{
                        				m_MtxResponse.lock();
                        
                        				if (m_ByteArrayRead.size() == 0)
                        				{
                        					if (m_boDebug)
                        					{
                        						throw(QString("AgilentLan Timeout"));
                        					}
                        					m_enRetVal = enRspTimeout;
                        				}
                        				else
                        				{
                        					m_enRetVal = enRspOK;
                        				}
                        
                        				m_MtxResponse.unlock();
                        				
                        				boRun_l = false;					
                        			}
                        		}
                        	}
                        	
                        	QThread::msleep(m_iResponseDelayed);
                        	
                        	QMutexLocker locker(&m_MtxProcess);
                        
                        	m_WaitCondProcess.wakeOne();
                        
                        }
                        

                        Diese Klasse möchte ich gerne umschreiben und zwar nach der vorgeschlagen "Qthread richtig einsetzen".
                        Das heisst ich muss eine neue Klassen erstellen, die von mir aus auch Worker heisst.

                        #include <QObject>
                        
                        class WorkerClass :public QObject
                        {
                        public:
                        	explicit WorkerClass(QObject *parent = 0);
                        	~WorkerClass();
                        
                        	public slots:
                        	void work();
                        };
                        

                        --> Das heisst für meinen Fall alle Aufrufe der run() Methode müssen jetzt in Slot Methode work() passieren natürlich mit entsprechenden

                         QObject::connect()
                        

                        in Konstrutor CAgilentLan(...) richtig?

                        Was mir wichtig bei diese Anpassung, dass der Änderung nur in diese klasse bleibt.
                        Ich will nicht überrall anpassen wo Objekte der klasse CAgilentLan aufgerufen sind deswegen bin ich bei der Änderung einbisschen vorsichtig.

                        Danke

                        J.HilkJ 1 Reply Last reply
                        0
                        • G Galilio

                          @Galilio said in QThread richtig einsetzen?:

                          Wenn ich folgenden habe:

                          Header File:

                          class QTcpSocket;
                          
                          class CAgilentLan : public QThread
                          {
                          
                          public:
                          
                          	typedef enum 
                          	{
                          		enRspTimeout = -2, 
                          		enRspOffline,
                          		enRspOK,
                          		enRspError
                          	} t_enRspType ;
                          
                          
                          	CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p=false, bool boDebug_p=false);
                          	~CAgilentLan();
                          
                          	// High-Level Funktionen
                          	QByteArray ExecuteGetScreenshot(void);
                          	void ExecuteSaveScreenshot(QString &strPathFileName_p, const char *strFormat_p);
                          	void ExecuteSettingsSave(unsigned char ucRegisterNo_p);
                          	void ExecuteSettingsRecall(unsigned char ucRegisterNo_p);
                          	double ExecuteQuickMeasure(unsigned char ucChannel_p, char *pchType_p);
                          	double ExecuteStatMeasure(char *pchType_p, bool boTrigger_p);
                          	void ExecuteResetMeasurementStatistics(void);
                          
                          	bool Open(const QString &strIpAdress_p, const int iTimeout_p);
                          	bool Close(const int iTimeout_p);
                          	t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                          	QByteArray GetLastResponse(void);
                          
                          	t_enRspType ExecuteSimulated(const char *strCmd_p);
                          	QString GetAgilentIdentifikation();
                          
                          	...
                          
                          protected:
                          	void run();
                          
                          private:
                          	bool m_boDebug;
                          	bool m_boSimulate;
                          	
                          	QMutex m_MtxProcess;
                          	QMutex m_MtxResponse;
                          
                          	QWaitCondition m_WaitCondProcess;
                          	QByteArray m_ByteArrayWrite;
                          	QByteArray m_ByteArrayRead;
                          
                          	QByteArray m_IDN_AgilentIdentification;
                          	
                          	//Hilfsvariable
                          	double m_SDDevPeriodeA ;
                          	double m_SDDevDCA;
                          	double m_SDDevDCB;
                          	double m_SDDevWidthZ;
                          
                          	double m_OZiSDDevPeriodeA;
                          	double m_OZiSDDevDCA;
                          	double m_OZiSDDevDCB;
                          	double m_OZiSDDevWidthZ;
                          
                          	double m_OZiMeanPeriodeA;
                          	double m_OZiMeanDCA;
                          	double m_OZiMeanDCB;
                          	double m_OZiMeanWidthZ;
                          	
                          	QByteArray m_ByteSTDD;
                          	QByteArray m_ByteMean;
                          	QStringList m_ListSTDDev;
                          	QStringList m_ListMean;
                          
                          	QTcpSocket *m_pTcpSctCtrl;
                          	
                          	QString m_strCtrlIP;
                          	int m_iTimeoutClose;
                          	int m_iTimeout;
                          	int m_iResponseDelayed;
                          	int m_iWaitResponse;
                          
                          	t_enRspType m_enRetVal;
                          };
                          
                          

                          cpp File:

                          CAgilentLan::CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p, bool boDebug_p):m_SDDevPeriodeA(0), m_SDDevDCA(0),m_SDDevDCB(0),m_SDDevWidthZ(0)
                          {
                          //	boSimulate_p = false;
                          	
                          	m_boDebug = boDebug_p;
                          	m_boSimulate = boSimulate_p;
                          
                          	m_enRetVal = enRspOffline;
                          	m_strCtrlIP = QString("");
                          	m_iTimeout = 0;
                          	m_iTimeoutClose = iTimeout_p;
                          	if (this->Execute("CreateObject", 0, 0, 0) != enRspOK)
                          	{
                          		throw(QString("Error AgilentLan.CPP/Constructor TcpSocket Create memory error"));
                          	}
                          
                          	this->Open(strIpAdress_p, iTimeout_p);
                          }
                          
                          CAgilentLan::~CAgilentLan()
                          {
                          	while(isRunning());
                          
                          	this->Close(m_iTimeoutClose);
                          
                          	while(isRunning());
                          	
                          	if (this->Execute("DeleteObject", 0, 0, 0) != enRspOK)
                          	{
                          		throw(QString("Error AgilentLan.CPP/Destructor TcpSocket Delete memory error"));
                          	}
                          
                          	
                          	while(isRunning());
                          }
                          bool CAgilentLan::Open(const QString &strCtrlIP_p, const int iTimeout_p)
                          {
                          	bool boRet_l = true;
                          
                          	m_strCtrlIP = strCtrlIP_p;
                          		
                          	if (this->Execute("OpenConnection", 0, iTimeout_p, 0) != enRspOK)
                          	{
                          		throw(QString("Error AgilentLan.CPP/Open TcpSocket Open Connection error"));
                          	}
                          	
                          	if (m_boDebug)
                          	{
                          		throw(QString("Tcp Socket is open"));
                          	}
                          
                          	return boRet_l;
                          }
                          
                          bool CAgilentLan::Close(const int iTimeout_p)
                          {
                          	bool boRet_l = true;
                          
                          	while(isRunning());
                          
                          	if (this->Execute("CloseConnection", 0, iTimeout_p, 0) != enRspOK)
                          	{
                          		throw(QString("Error AgilentLan.CPP/Close Connection error"));
                          	}
                          	
                          	if (m_boDebug)
                          	{
                          		throw(QString("Tcp Socket is closed"));
                          	}
                          
                          	while(isRunning());
                          
                          	return boRet_l;
                          }
                          
                          
                          CAgilentLan::t_enRspType CAgilentLan::Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p)
                          {
                          	CAgilentLan::t_enRspType enRetVal_l = enRspOffline;
                          
                          	if (!isRunning())
                          	{
                          		m_ByteArrayRead.clear();
                          
                          		m_ByteArrayWrite.clear();
                          		m_ByteArrayWrite.append(strCmd_p);
                          		
                          		m_iWaitResponse = iWaitResponse_p;
                          		m_iTimeout = iTimeout_p;
                          		m_iResponseDelayed = iRspDelayed_p;
                          
                          		start();
                          
                          		m_MtxProcess.lock();
                          		m_WaitCondProcess.wait(&m_MtxProcess,-1);
                          		m_MtxProcess.unlock();
                          	
                          		enRetVal_l = this->m_enRetVal;
                          	}
                          	else
                          	{
                          		enRetVal_l = enRspError;
                          	}
                          	
                          	while(isRunning());
                          	
                          	return enRetVal_l;
                          }
                          
                          QByteArray CAgilentLan::GetLastResponse(void)
                          {
                          	QByteArray ay_l;
                          
                          	m_MtxResponse.lock();
                          	ay_l = m_ByteArrayRead;
                          	m_MtxResponse.unlock();
                          
                          	return ay_l;
                          }
                          void CAgilentLan::run()
                          {
                          	bool boRun_l = true;
                          	bool boSent_l = false;
                          
                          	const char *pStrCmd_l = NULL;
                          	const char *pStrRsp_l = NULL;
                          
                          	m_enRetVal = enRspError;
                          
                          	if (strcmp(m_ByteArrayWrite.data(),"CreateObject")==0)
                          	{
                          		if (this->m_boSimulate == true)
                          		{
                          			m_enRetVal = enRspOK;
                          		}
                          		else
                          		{
                          			m_pTcpSctCtrl = (QTcpSocket *)new QTcpSocket;
                          			if (m_pTcpSctCtrl != NULL)
                          			{
                          				m_enRetVal = enRspOK;
                          			}
                          		}
                          
                          		boRun_l = false;
                          	}
                          
                          	if (strcmp(m_ByteArrayWrite.data(),"DeleteObject")==0)
                          	{
                          		if (this->m_boSimulate == true)
                          		{
                          		}
                          		else
                          		{
                          			if (m_pTcpSctCtrl != NULL)
                          			{
                          				delete m_pTcpSctCtrl;
                          			}
                          		}
                          
                          		m_enRetVal = enRspOK;
                          		boRun_l = false;
                          	}
                          
                          	if (strcmp(m_ByteArrayWrite.data(),"OpenConnection")==0)
                          	{
                          		if (this->m_boSimulate == true)
                          		{
                          			m_enRetVal = enRspOK;
                          		}
                          		else
                          		{
                          			m_pTcpSctCtrl->connectToHost(m_strCtrlIP,5025);
                          			if (m_pTcpSctCtrl->waitForConnected(m_iTimeout) == true)
                          			{
                          				m_enRetVal = enRspOK;
                          			}
                          		}
                          		
                          		boRun_l = false;
                          	}
                          
                          	if (strcmp(m_ByteArrayWrite.data(),"CloseConnection")==0)
                          	{
                          		if (this->m_boSimulate == true)
                          		{
                          			m_enRetVal = enRspOK;
                          		}
                          		else
                          		{
                          			m_pTcpSctCtrl->disconnectFromHost();
                          			if ((m_pTcpSctCtrl->state() == QAbstractSocket::UnconnectedState) || (m_pTcpSctCtrl->waitForDisconnected(m_iTimeout)))
                          			{
                          				m_enRetVal = enRspOK;
                          			}
                          		}
                          		
                          		boRun_l = false;
                          	}
                          
                          	int iTimeout_l = m_iTimeout;
                          	
                          	while (boRun_l && (!this->m_boSimulate))
                          	{
                           		if (boSent_l == false)
                          		{
                          			boSent_l = true;
                          			// Kommando absetzen
                          			m_pTcpSctCtrl->write(m_ByteArrayWrite.data(),m_ByteArrayWrite.size());
                          			// Auf Antwort warten
                          			if (m_iWaitResponse >= 0)
                          			{
                          				QThread::msleep(m_iWaitResponse);
                          			}
                          			else
                          			{
                          				boRun_l = false;
                          			}
                          		}
                          		
                          		// Anwort auf Kommando abwarten	
                          		if ((m_pTcpSctCtrl->bytesAvailable() > 0) && (boRun_l == true))
                          		{
                          			m_MtxResponse.lock();
                          
                          			m_ByteArrayRead.append(m_pTcpSctCtrl->readAll());
                          			
                          			if (m_boDebug)
                          			{
                          				throw(QString(m_ByteArrayRead.data()));
                          			}
                          
                          			m_MtxResponse.unlock();
                          
                          			iTimeout_l = m_iTimeout;
                          //			iTimeout_l = m_iWaitResponse;
                          		}
                          		else
                          		{
                          			if (m_pTcpSctCtrl->waitForReadyRead(iTimeout_l) == false)
                          			{
                          				m_MtxResponse.lock();
                          
                          				if (m_ByteArrayRead.size() == 0)
                          				{
                          					if (m_boDebug)
                          					{
                          						throw(QString("AgilentLan Timeout"));
                          					}
                          					m_enRetVal = enRspTimeout;
                          				}
                          				else
                          				{
                          					m_enRetVal = enRspOK;
                          				}
                          
                          				m_MtxResponse.unlock();
                          				
                          				boRun_l = false;					
                          			}
                          		}
                          	}
                          	
                          	QThread::msleep(m_iResponseDelayed);
                          	
                          	QMutexLocker locker(&m_MtxProcess);
                          
                          	m_WaitCondProcess.wakeOne();
                          
                          }
                          

                          Diese Klasse möchte ich gerne umschreiben und zwar nach der vorgeschlagen "Qthread richtig einsetzen".
                          Das heisst ich muss eine neue Klassen erstellen, die von mir aus auch Worker heisst.

                          #include <QObject>
                          
                          class WorkerClass :public QObject
                          {
                          public:
                          	explicit WorkerClass(QObject *parent = 0);
                          	~WorkerClass();
                          
                          	public slots:
                          	void work();
                          };
                          

                          --> Das heisst für meinen Fall alle Aufrufe der run() Methode müssen jetzt in Slot Methode work() passieren natürlich mit entsprechenden

                           QObject::connect()
                          

                          in Konstrutor CAgilentLan(...) richtig?

                          Was mir wichtig bei diese Anpassung, dass der Änderung nur in diese klasse bleibt.
                          Ich will nicht überrall anpassen wo Objekte der klasse CAgilentLan aufgerufen sind deswegen bin ich bei der Änderung einbisschen vorsichtig.

                          Danke

                          J.HilkJ Offline
                          J.HilkJ Offline
                          J.Hilk
                          Moderators
                          wrote on last edited by
                          #11

                          @Galilio
                          Hi, sorry für die späte Antwort, war nen langes Wochenende :-)

                          Ok, lass mich hier klar stellen, von QThread abzuleiten ist per se nicht falsch und auch weiterhin eine legitime Möglichkeit einen Thread zu betreiben. Nicht ohne Grund war das,bis vor einiger Zeit, auch die in der Doku beschriebenen Methode.

                          D.h. wenn du bereits eine funktionierende Implementation hast, was ich aus deinem Codebeispiel schließe, würde ich mir nicht die Mühe machen und das umschreiben wollen, das ist nämlich nicht so einfach.

                          Reimplementieren von QThread/Run und Worker-Ansatzt sind vom Aufbau her unterschiedlich. Auch wenn sie im Prinzip auf das selbe zurückgreifen.

                          Bei QThread/Run setzt man da an, das run Zyklisch(CPU-Abhängig) aufgerufen wird, davon ausgehend Funktionen aufgerufen etc- in der Regel macht man dazu eine While-Schleife innerhalb der RUN da ansonsten der Thread am Ende der Funktion fertig ist.
                          Der Worker-Object Ansatz ist mehr Event-orientiert. Dort wird QThread, so eingesetzt wie es angedacht war, als Thread-Warpper. Dort wird dann RUN als eigene event-loop aufgerufen, was die Objekte die man übergeben hat, am leben erhält.

                          Zu deiner Frage:
                          Nein, so einfach sollte man das nicht machen.

                          Da müsste gute Menge umgeschrieben werden.
                          Ganz grob:
                          in "Run" müsste nur TCP-Socket initialisiert werden(new und Connects), und dann der Rest ausgelagert in eigene Funktionen und zugegriffen von "außerhalb" über Signal/Slots.


                          Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


                          Q: What's that?
                          A: It's blue light.
                          Q: What does it do?
                          A: It turns blue.

                          1 Reply Last reply
                          0
                          • G Offline
                            G Offline
                            Galilio
                            wrote on last edited by
                            #12

                            Guten Morgen und danke für die Antwort.
                            Grund warum ich das ändern möchte, ist beim Debug version und nur beim Visual Studio 2015 Problem habe beim dieses Class "CAgilentLan".
                            Grund habe ich immer noch nicht gefunden.

                            J.HilkJ 1 Reply Last reply
                            0
                            • G Galilio

                              Guten Morgen und danke für die Antwort.
                              Grund warum ich das ändern möchte, ist beim Debug version und nur beim Visual Studio 2015 Problem habe beim dieses Class "CAgilentLan".
                              Grund habe ich immer noch nicht gefunden.

                              J.HilkJ Offline
                              J.HilkJ Offline
                              J.Hilk
                              Moderators
                              wrote on last edited by
                              #13

                              @Galilio said in QThread richtig einsetzen?:

                              Guten Morgen und danke für die Antwort.
                              Grund warum ich das ändern möchte, ist beim Debug version und nur beim Visual Studio 2015 Problem habe beim dieses Class "CAgilentLan".
                              Grund habe ich immer noch nicht gefunden.

                              Kannst ja mal den exakten Fehler hier posten, da kann dir gewiss jemand helfen :)


                              Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


                              Q: What's that?
                              A: It's blue light.
                              Q: What does it do?
                              A: It turns blue.

                              1 Reply Last reply
                              0
                              • G Offline
                                G Offline
                                Galilio
                                wrote on last edited by
                                #14

                                Problem tritt nur in Debug Version in Release ist alles okay.
                                Die Class "CAgilentLan" ist verantwortlich für die Oscilloscope kumminikation.
                                Also wird mit der Oscillocope kummniziert muss von diesem Object einen Reference erstellt werden in der Art :

                                CAgilentLan DSO_l(settings_l.strfuGetIP_DSO(), iConstTimeoutOpenCloseDSO, settings_l.bofuGetSimulate());
                                

                                diese Object ruft wieder der Konstructor und ...

                                dann beim verlassen der definierten Anweisung Block natürlich wird der destructor aufgerufen und hier dann kracht.
                                Hier ist die fehlermeldung:

                                ASSERT: "d->active_fd.isEmpty()" in file kernel\qeventdispatcher_win.cpp, line 1248
                                Debug Error!

                                ich wiederhole mich noch mal .Beim release habe ich das Problem nicht.

                                1 Reply Last reply
                                0
                                • G Offline
                                  G Offline
                                  Galilio
                                  wrote on last edited by
                                  #15

                                  @J-Hilk

                                  Kannst du bitte mich helfen ?
                                  Ich komme echt gar nicht weiter und weiss es nicht was und wo ist das Problem?

                                  Danke

                                  J.HilkJ 1 Reply Last reply
                                  0
                                  • G Galilio

                                    @J-Hilk

                                    Kannst du bitte mich helfen ?
                                    Ich komme echt gar nicht weiter und weiss es nicht was und wo ist das Problem?

                                    Danke

                                    J.HilkJ Offline
                                    J.HilkJ Offline
                                    J.Hilk
                                    Moderators
                                    wrote on last edited by
                                    #16

                                    @Galilio
                                    hi, kommt das Oszilloskop mit eigenen dll's die du einbindest?

                                    So ein crash in Debug aber nicht in Release kann damit zusammen hängen, wenn zum Beipspeil ein Object in einer dll erzeugt und von einer anderen zerstört wird. Zugewiesener Speicher sollte immer immer von dem Modul freigegeben werden der ihn auch reseverviert.

                                    Man braucht ein wenig mehr Info, poste doch mal mehr vom Stacktrace und wenn möglich mehr vom problem-Code als eine Zeile.


                                    Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


                                    Q: What's that?
                                    A: It's blue light.
                                    Q: What does it do?
                                    A: It turns blue.

                                    G 2 Replies Last reply
                                    0
                                    • J.HilkJ J.Hilk

                                      @Galilio
                                      hi, kommt das Oszilloskop mit eigenen dll's die du einbindest?

                                      So ein crash in Debug aber nicht in Release kann damit zusammen hängen, wenn zum Beipspeil ein Object in einer dll erzeugt und von einer anderen zerstört wird. Zugewiesener Speicher sollte immer immer von dem Modul freigegeben werden der ihn auch reseverviert.

                                      Man braucht ein wenig mehr Info, poste doch mal mehr vom Stacktrace und wenn möglich mehr vom problem-Code als eine Zeile.

                                      G Offline
                                      G Offline
                                      Galilio
                                      wrote on last edited by
                                      #17

                                      @J.Hilk said in QThread richtig einsetzen?:

                                      hi, kommt das Oszilloskop mit eigenen dll's die du einbindest?

                                      Was meinst du genau?
                                      Um die verbindung zu Oszilloskop zu ermöglichen wurde diese Class geschrieben.
                                      Also es gibt keine andere DLL, die verwendet wurde.
                                      Eine Sache noch: Bei Visual Studio 2008 und Qt4.8 Plugin habe ich das Problem nicht.

                                      So ein crash in Debug aber nicht in Release kann damit zusammen hängen, wenn zum Beipspeil ein Object in einer dll erzeugt und von einer anderen zerstört wird. Zugewiesener Speicher sollte immer immer von dem Modul freigegeben werden der ihn auch reseverviert.

                                      Ich glaube dises Fall trifft mich nicht.

                                      Man braucht ein wenig mehr Info, poste doch mal mehr vom Stacktrace und wenn möglich mehr vom problem-Code als eine Zeile

                                      1 Reply Last reply
                                      0
                                      • J.HilkJ J.Hilk

                                        @Galilio
                                        hi, kommt das Oszilloskop mit eigenen dll's die du einbindest?

                                        So ein crash in Debug aber nicht in Release kann damit zusammen hängen, wenn zum Beipspeil ein Object in einer dll erzeugt und von einer anderen zerstört wird. Zugewiesener Speicher sollte immer immer von dem Modul freigegeben werden der ihn auch reseverviert.

                                        Man braucht ein wenig mehr Info, poste doch mal mehr vom Stacktrace und wenn möglich mehr vom problem-Code als eine Zeile.

                                        G Offline
                                        G Offline
                                        Galilio
                                        wrote on last edited by
                                        #18

                                        @J.Hilk
                                        Kannst du bitte mich auf die Sprünge helfen?
                                        Ich habe es so angefangen:

                                        class QTcpSocket;
                                         
                                        class CAgilentLan : public QObject
                                        {
                                        	Q_OBJECT
                                         
                                        public:
                                         ...
                                            CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p=false, bool boDebug_p=false);
                                            ~CAgilentLan();
                                         
                                        ...
                                            t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                                         ..
                                         
                                        public slots:
                                            void AgilentStart();
                                         
                                        
                                        };
                                        

                                        Die run() Methode umbenannt und zu einen Slot deklariert.
                                        Mir ist dann nicht ganz klar wie soll ich die restlichen Methoden zu SLOT und SIGNAL einbinden kann?
                                        In der alte Version was diese Methode :

                                        t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                                        
                                        

                                        Zentral. Das heisst jede aufruf diese Methode verusacht eine automatische aufruf der run() Methode.
                                        Ich will weiterhin dieses Ablauf beibehalten damit die Änderung minimal bleibt.
                                        Dir danke ich in voraus

                                        J.HilkJ 1 Reply Last reply
                                        0
                                        • G Galilio

                                          @J.Hilk
                                          Kannst du bitte mich auf die Sprünge helfen?
                                          Ich habe es so angefangen:

                                          class QTcpSocket;
                                           
                                          class CAgilentLan : public QObject
                                          {
                                          	Q_OBJECT
                                           
                                          public:
                                           ...
                                              CAgilentLan(QString strIpAdress_p, int iTimeout_p, bool boSimulate_p=false, bool boDebug_p=false);
                                              ~CAgilentLan();
                                           
                                          ...
                                              t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                                           ..
                                           
                                          public slots:
                                              void AgilentStart();
                                           
                                          
                                          };
                                          

                                          Die run() Methode umbenannt und zu einen Slot deklariert.
                                          Mir ist dann nicht ganz klar wie soll ich die restlichen Methoden zu SLOT und SIGNAL einbinden kann?
                                          In der alte Version was diese Methode :

                                          t_enRspType Execute(const char *strCmd_p, const int iWaitResponse_p, const int iTimeout_p, const int iRspDelayed_p);
                                          
                                          

                                          Zentral. Das heisst jede aufruf diese Methode verusacht eine automatische aufruf der run() Methode.
                                          Ich will weiterhin dieses Ablauf beibehalten damit die Änderung minimal bleibt.
                                          Dir danke ich in voraus

                                          J.HilkJ Offline
                                          J.HilkJ Offline
                                          J.Hilk
                                          Moderators
                                          wrote on last edited by
                                          #19

                                          @Galilio ich guck mal ob ich heute Abend Zeit finde eine ausführliche Antwort zu erstellen.


                                          Be aware of the Qt Code of Conduct, when posting : https://forum.qt.io/topic/113070/qt-code-of-conduct


                                          Q: What's that?
                                          A: It's blue light.
                                          Q: What does it do?
                                          A: It turns blue.

                                          G 1 Reply Last reply
                                          0
                                          • J.HilkJ J.Hilk

                                            @Galilio ich guck mal ob ich heute Abend Zeit finde eine ausführliche Antwort zu erstellen.

                                            G Offline
                                            G Offline
                                            Galilio
                                            wrote on last edited by
                                            #20

                                            @J.Hilk
                                            Hi
                                            danke dir
                                            Eigentlich in jede Stelle wo das Object:

                                            CAgilentLan
                                            

                                            aufegerufen wird muss ich folgende schreiben:

                                            	QThread * workerThread = new QThread();
                                            	CAgilentLan *workerObject = new CAgilentLan(.....);
                                            	workerObject->moveToThread(workerThread);
                                            	connect(workerThread, &QThread::started, workerObject, &CAgilentLan::agilentStart);
                                                   // aufräumen
                                            	connect(workerThread, &QThread::finished, workerThread, &QThread::deleteLater);
                                            	connect(workerThread, &QThread::finished, workerObject, &CAgilentLan::deleteLater);
                                            

                                            Ist das so richtig?

                                            G 1 Reply Last reply
                                            0

                                            • Login

                                            • Login or register to search.
                                            • First post
                                              Last post
                                            0
                                            • Categories
                                            • Recent
                                            • Tags
                                            • Popular
                                            • Users
                                            • Groups
                                            • Search
                                            • Get Qt Extensions
                                            • Unsolved