Два способа использования QThread

#ifndef TESTCLASS_H
#define TESTCLASS_H
 
#include <QObject>
 
class TestClass : public QObject
{
    Q_OBJECT
    public:
        TestClass(int);
    private:
        int num;
    public slots:
        void run();
    signals:
        void finished();
};
 
#endif // TESTCLASS_H

#include "TestClass.h"
#include <QDebug>
 
TestClass::TestClass(int i)
{
    num=i;
}
 
void TestClass::run() {
    for (int i=0; i< 5000; ++i) {qDebug()<<"from "<<num; }
    emit finished();
}

#ifndef SPECIALTHREAD_H
#define SPECIALTHREAD_H
 
#include <QThread>
#include "TestClass.h"
 
class SpecialThread : public QThread
{
public:
    SpecialThread();
    void setTestClass(TestClass*);
private:
    TestClass* pTestObject;
public:
    void run();
};
#endif // SPECIALTHREAD_H

#include "specialthread.h"
 
SpecialThread::SpecialThread()
{
    pTestObject=0;
}
 
void SpecialThread::setTestClass(TestClass *pTO) {
    pTestObject=pTO;
}
 
void SpecialThread::run() {
    if (pTestObject) {
         pTestObject->run();
    }
}

#include <QtCore/QCoreApplication>
#include "TestClass.h"
#include <QThread>
#include <QtConcurrentRun>
#include "SpecialThread.h"
 
int main(int argc, char *argv[]){
 
    QCoreApplication a(argc, argv);
 
//------- Way 1 ---------
 
    SpecialThread thread1;
    SpecialThread thread2;
 
    TestClass text1(1);
    TestClass text2(2);
 
    thread1.setTestClass(&text1);
    thread2.setTestClass(&text2);
 
    thread1.start();
    thread2.start();
 
    return a.exec();
}

#include <QtCore/QCoreApplication>
#include "TestClass.h"
#include <QThread>
#include <QtConcurrentRun>
#include "SpecialThread.h"
 
int main(int argc, char *argv[]){
 
    QCoreApplication a(argc, argv);
 
//------- Way 2 ---------
 
    QThread thread1;
    QThread thread2;
 
    TestClass text1(1);
    TestClass text2(2);
 
    QObject::connect(&thread1,SIGNAL(started()),&text1,SLOT(run()));
    QObject::connect(&text1,SIGNAL(finished()),&thread1,SLOT(terminate()));
 
    QObject::connect(&thread2,SIGNAL(started()),&text2,SLOT(run()));
    QObject::connect(&text2,SIGNAL(finished()),&thread2,SLOT(terminate()));
 
    text1.moveToThread(&thread1);
    text2.moveToThread(&thread2);
 
    thread1.start();
    thread2.start();
 
    return a.exec();
}

#include <QtCore/QCoreApplication>
#include "TestClass.h"
#include <QThread>
#include <QtConcurrentRun>
#include "SpecialThread.h"
 
int main(int argc, char *argv[]){
 
    QCoreApplication a(argc, argv);
 
//------- Way 3 ---------
 
    TestClass text1(1);
    TestClass text2(2);
 
    QtConcurrent::run(&text1,&TestClass::run);
    QtConcurrent::run(&text2,&TestClass::run);
 
    return a.exec();
 
}

// worker.h
#ifndef WORKER_H
#define WORKER_H
 
#include <QThread>
#include <QDebug>
#include <QTextBrowser>
#include <QFile>
#include <QString>
 
class Worker : public QThread
{
public:
    Worker();
    void SetObject(QTextBrowser *i_textbrowser);
    void run();
    void OpenFile();
private:
    void read_and_output();
    QTextBrowser *m_textbrowser;
    QFile m_debug_file;
};
#endif // WORKER_H

// worker.cpp
#include "worker.h"
 
Worker::Worker() {
}
 
void Worker::OpenFile() {
    m_debug_file.setFileName("debug");
    if(m_debug_file.open(QIODevice::ReadOnly))
        qDebug() << "Open file!!!";
    else
        qDebug() << "Can't open debug file...";
}
 
void Worker::read_and_output() {
    QString l_all_strings = m_debug_file.readAll();
    qDebug() << l_all_strings;
    m_textbrowser->setText(l_all_strings);
    m_textbrowser->reload();
}
 
void Worker::run() {
    OpenFile();
    for (int i = 0; i < 100; i++) {
        msleep(300);
        read_and_output();
    }
}
 
void Worker::SetObject(QTextBrowser *i_textbrowser) {
    m_textbrowser = i_textbrowser;
}

//mainwindow.cpp
//...
void MainWindow::on_pushButton_clicked() {
    //w - объект типа worker!!!
    w.SetObject(ui->textBrowser);
    w.start();
}
//...

// прекращаем обработку event loop потока
connect(worker, SIGNAL(finished()), thread, SLOT(quit()));
// запланировали отложенное убийство "работяги"
connect(worker, SIGNAL(finished()), worker, SLOT(deleteLater()));
// запланировали отложенное убийство потока
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));