Как сделать вторичный поток с постоянный жизненным циклом и управлением из главного потока

#ifndef THREADOBJECTBALANCER_H
#define THREADOBJECTBALANCER_H
 
#include <QObject>
#include<QDebug>
 
class ThreadObjectBalancer : public QObject
{
    Q_OBJECT
 
    // Свойство, управляющее работой потока
    Q_PROPERTY(bool running READ running WRITE setRunning NOTIFY runningChanged)
    // Первое сообщение в объекте
    Q_PROPERTY(QString message READ message WRITE setMessage NOTIFY messageChanged)
    // Второе сообщение, которое будем передавать через сигнал/слот во второй объект
    Q_PROPERTY(QString message_2 READ message_2 WRITE setMessage_2 NOTIFY message_2Changed)
 
    bool m_running;
    QString m_message;
    QString m_message_2;
    int count;  // Счётчик, по которому будем ориентироваться на то,
                // что потоки выполняются и работают
public:
    explicit ThreadObjectBalancer(QObject *parent = 0);
    bool running() const;
    QString message() const;
    QString message_2() const;
 
signals:
    void finished();    // Сигнал, по которому будем завершать поток, после завершения метода run
    void runningChanged(bool running);
    void messageChanged(QString message);
    void message_2Changed(QString message_2);
    void sendMessage(QString message);
 
public slots:
    void run(); // Метод с полезной нагрузкой, который может выполняться в цикле
    void setRunning(bool running);
    void setMessage(QString message);
    void setMessage_2(QString message_2);
};
 
#endif // THREADOBJECTBALANCER_H

#include "threadobjectbalancer.h"
 
ThreadObjectBalancer::ThreadObjectBalancer(QObject *parent) :
    QObject(parent),
    m_message(""),
    m_message_2("")
{
 
}
 
 
bool ThreadObjectBalancer::running() const
{
    return m_running;
}
 
 
QString ThreadObjectBalancer::message() const
{
   return m_message;
}
 
 
QString ThreadObjectBalancer::message_2() const
{
    return m_message_2;
}
 
 
void ThreadObjectBalancer::run()
{
    count = 0;
 
    while (m_running)
    {
        count++;
      //  emit sendMessage(m_message); // Высылаем данные, которые будут передаваться в другой поток
        qDebug() << m_message << " " << m_message_2 << " " << count;
    }
    emit finished();
}
 
 
void ThreadObjectBalancer::setRunning(bool running)
{
    if (m_running == running)
        return;
 
    m_running = running;
    count = 0;
    emit runningChanged(running);
}
 
 
void ThreadObjectBalancer::setMessage(QString message)
{
    if (m_message == message)
        return;
 
    m_message = message;
    emit messageChanged(message);
}
 
 
void ThreadObjectBalancer::setMessage_2(QString message_2)
{
    if (m_message_2 == message_2)
        return;
 
    m_message_2 = message_2;
    emit message_2Changed(message_2);
}

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QTimer>
#include <QTime>
#include <QDate>
#include <QPainter>
#include <QKeyEvent>
#include <mythreadbalancer.h>
#include <threadobjectbalancer.h>
#include <QThread>
 
namespace Ui {
class MainWindow;
}
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    MyThreadBalancer *myThreadBalancer;
 
protected:
   void paintEvent(QPaintEvent *event);
   void mousePressEvent(QMouseEvent *e);
   void keyPressEvent(QKeyEvent *event);
 
signals:
    void SignalModeWork(int*bal);
 
private slots:
    void slotTimerAlarm();
    void on_write_1_clicked();  // Слот для записи данных из lineEdit_1 в первый объект первого потока
    void on_write_2_clicked();  // Слот для записи данных из lineEdit_1 во второй объект второго потока
 
public slots:
    void onNumberChanged(int *balancer);
    void clearText(bool);
 
private:
    Ui::MainWindow *ui;
    QTimer *timer;
    QThread thread_1;       // Первый поток
    QThread thread_2;       // Второй поток
    ThreadObjectBalancer exampleObject_1;  // первый объект, который будет работать в первом потоке
    ThreadObjectBalancer exampleObject_2;  // второй объект, который будет работать во втором потоке
};
 
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <stdio.h>
#include <QDebug>
#include <QPixmap>
#include <menu_1.h>
 
#include <QKeyEvent>
 
#include <stdio.h>
#include <unistd.h>
#include <stdio.h>
 
int ArrayBalanser[260];
int counterBalanser =0;
int latch = 0;
 
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
 
       QPixmap myPixmap( "crvd.png" );
 
       if(!myPixmap.isNull())
       {
           ui->label_3->setPixmap(myPixmap);
       }
       else
       {
           qDebug() << "Cannot find picture";
       }
 
       QFont font = ui->label_2->font();
       font.setPointSize(24);
       ui->label_2->setFont(font);
       ui->label_2->setText(QTime::currentTime().toString("hh:mm:ss") + "\n" + QDate::currentDate().toString("dd.MM.yy"));
 
       timer = new QTimer();
       connect(timer, SIGNAL(timeout()), this, SLOT(slotTimerAlarm()));
       timer->start(1000); // И запустим таймер
 
       myThreadBalancer = new MyThreadBalancer(this);
       connect(myThreadBalancer,SIGNAL(NumberChanged(int*)), this, SLOT(onNumberChanged(int*)));
       connect(myThreadBalancer,SIGNAL(Cleartext(bool)), this, SLOT(clearText(bool)));
 
       myThreadBalancer->Stop = false;
       myThreadBalancer->start();
 
 
 
 
 
       ThreadObjectBalancer *first=new ThreadObjectBalancer();
       ThreadObjectBalancer *second=new ThreadObjectBalancer();
       QThread *thread1=new QThread;
       QThread *thread2=new QThread;
       QObject::connect(&thread_1,        SIGNAL(started()),&exampleObject_1, SLOT(run()));
       QObject::connect(thread1, SIGNAL(started()),  first,   SLOT(run()));
       QObject::connect(thread2, SIGNAL(started()),  second,  SLOT(run()));
       QObject::connect(first,   SIGNAL(finished()), thread1, SLOT(quit()));
       QObject::connect(second,  SIGNAL(finished()), thread2, SLOT(quit()));
       first->moveToThread(thread1);
       second->moveToThread(thread2);
       exampleObject_1.setRunning(true);
       exampleObject_2.setRunning(true);
       thread1->start();
       thread2->start();
}
 
 
MainWindow::~MainWindow()
{
    delete ui;
}
 
 
void MainWindow::keyPressEvent(QKeyEvent *event)
{
    switch(event->key()){
    case Qt::Key_Up:
 
             qDebug()<<"Press Up";
               break;
 
           case Qt::Key_Down:
              qDebug()<<"Press Down";
               break;
 
           case Qt::Key_Enter:
            exampleObject_1.setRunning(false);
            exampleObject_2.setRunning(false);
 
              qDebug()<<"Press Enter";
               break;
 
           case Qt::Key_Left:
              qDebug()<<"Press Left";
               break;
 
           case Qt::Key_Right:
               qDebug()<<"Press Right";
                break;
    }
 
     QMainWindow::keyPressEvent(event);
}