connectionthread.h

#ifndef CONNECTIONTHREAD_H
#define CONNECTIONTHREAD_H

#include <QThread>
#include <QMutex>
#include <QWaitCondition>

class ConnectionThread : public QThread
{
    Q_OBJECT

public:
    ConnectionThread(QObject *parent = nullptr);
    ~ConnectionThread();

    void requestNewData(const QString &hostName, quint16 port, const QString &message);
    void run() override;

signals:
    void newData(const QByteArray &data);
    void error(int socketError, const QString &message);

private:
    QString m_hostName;
    quint16 m_port;
    QString m_message;
    QMutex m_mutex;
    QWaitCondition m_cond;
    bool m_quit;
};

#endif // CONNECTIONTHREAD_H

connectionthread.cpp

#include <QtNetwork>

#include "connectionthread.h"

ConnectionThread::ConnectionThread(QObject *parent)
    : QThread(parent), m_quit(false)
{
}

ConnectionThread::~ConnectionThread()
{
    m_mutex.lock();
    m_quit = true;
    m_cond.wakeOne();
    m_mutex.unlock();
    wait();
}

void ConnectionThread::requestNewData(const QString &hostName, quint16 port, const QString &message)
{
    QMutexLocker locker(&m_mutex);
    m_hostName = hostName;
    m_port = port;
    m_message = message;

    if (!isRunning())
        start();
    else
        m_cond.wakeOne();
}
void ConnectionThread::run()
{
    m_mutex.lock();

    QString serverName = m_hostName;
    quint16 serverPort = m_port;
    m_mutex.unlock();

    while (!m_quit) {
        const int Timeout = 3 * 1000; // 3 sec.

        QTcpSocket socket;
        socket.connectToHost(serverName, serverPort);

        if (!socket.waitForConnected(Timeout)) {
            emit error(socket.error(), socket.errorString());
            return;
        }

        qDebug() << tr("Sending %1 to the server").arg(m_message);
        socket.write(m_message.toUtf8());


        QByteArray data;
        if (!socket.waitForReadyRead(Timeout)) {
            emit error(socket.error(), socket.errorString());
            return;
        }
        data = socket.readAll();

        m_mutex.lock();
        emit newData(data);

        m_cond.wait(&m_mutex);
        serverName = m_hostName;
        serverPort = m_port;
        m_mutex.unlock();
    }
}

In the main code, I connect the thread with

ConnectionThread m_thread;

connect(&m_thread, &ConnectionThread::newData,
        this, &Client::readData);

connect(&m_thread, &ConnectionThread::error,
        this, &Client::displayError);

m_thread.requestNewData(m_ip_address, m_port, m_messages[m_msgidC2]);

...

It works well so far. Yet, now I need to keep the connection opened, i.e. not reconnect, each time I send a new message (with requestNewData())

I do not know how to modify my code to achieve that.

What I tried is to define the socket as a member of ConnectionThread. Then in the run() function, I call socket.connectToHost() only if socket.state() is not equal QTcpSocket::connected.

But doing so, I get message like this one
QObject: Cannot create children for a parent that is in a different thread.
(Parent is QTcpSocket(0x559b0576ae30), parent's thread is QThread(0x559b04f23660), current thread is ConnectionThread(0x559b05582b40)

Any idea of design?