I>class Window
I>signal:
I>    void writeToUdp(QByteArray)

I>Window::Window() {
I>    connect(this, &Window::writeToUdp, &worker2, &Worker2::writeToUdp3);

I>void Window::launchWrite() {
I>    //...
I>    emit writeToUdp(byte_array);
I>}

I>class Worker3 : public QObject {
I>public slots:
I>    void writeToUdp3(const QByteArray& qBinArray)

class Window : public QWidget
{
    Q_OBJECT
signals:
    void writeCommandData(const QByteArray &);// второй вариант
private:
    Worker2 worker;
    QThread m_Thread;
    Worker3 worker3;
    QThread m_Thread3;
};
Window::Window()
{
    worker.moveToThread( &m_Thread );
    connect(&worker, &Worker2::resultReady, this, &Window::appendtoLogListBox);
    connect(&worker, &Worker2::sendData, this, &Window::displayImage);
    worker.startStrm();
    m_Thread.start(QThread::NormalPriority);

    worker3.moveToThread( &m_Thread3 );
    connect(this,&Window::writeCommandData,&worker3,&Worker3::writeToUdp3);
    worker3.startStrm3();
    m_Thread3.start(QThread::NormalPriority);
}
Window::~Window()
{
    bool b_result=false;
    worker.stopStrm();
    m_Thread.quit();
    b_result=m_Thread.wait(200);
    qDebug() << "m_Thread.wait(200) = " << b_result;
    worker3.stopStrm3();
    m_Thread3.quit();
    b_result=m_Thread3.wait(200);
    qDebug() << "m_Thread3.wait(200) = " << b_result;
// waitForFinished нет в QThread (Qt 5.6.2),а есть в QFuture
}

void Window::launchWrite()
{
    QByteArray byte_array;
    byte_array.resize(648);
    for(int j=0;j<480;j++)
    {
        for(int i=0;i<648;i++)
        {
            byte_array[i]=i;
        }
        emit writeCommandData(byte_array);
    }
    return;
}

class Worker2 : public QObject
{
    Q_OBJECT
private:
    QScopedPointer<QUdpSocket> m_pSocket;
public:
    void startStrm()
    {
        QMetaObject::invokeMethod(this, "doStart", Qt::QueuedConnection);
    }
    void stopStrm()
    {
        QMetaObject::invokeMethod(this, "doStop", Qt::QueuedConnection);
    }
public slots:
    void doStart()
    {
        m_pSocket.reset( new QUdpSocket() );
        result=m_pSocket->bind( QHostAddress::AnyIPv4 , 50012);
        connect(m_pSocket.data(), &QUdpSocket::readyRead,this,&Worker2::readPendingDatagrams);
    }
    void doStop()
    {
        disconnect(m_pSocket.data(), &QUdpSocket::readyRead,this,&Worker2::readPendingDatagrams);
        m_pSocket.reset();
    }

public:
    void readPendingDatagrams()
    {
        QByteArray buffer;
        while(m_pSocket->hasPendingDatagrams())
        {
            size_of_data=m_pSocket->pendingDatagramSize();
            if(-1==size_of_data) continue;
            buffer.resize(m_pSocket->pendingDatagramSize());
            ret_value=m_pSocket->readDatagram(buffer.data(),buffer.size(),&sender,&senderPort);
            setUdpData(buffer);
        }
    }
signals:
    void resultReady(const QString &result);
    void sendData(const QImage &image);
};

class Worker3 : public QObject
{
    Q_OBJECT
private:
    QScopedPointer<QUdpSocket> m_pSocket3;
public:
    void startStrm3()
    {
        QMetaObject::invokeMethod(this, "doStart3", Qt::QueuedConnection);
    }
    void stopStrm3()
    {
        QMetaObject::invokeMethod(this, "doStop3", Qt::QueuedConnection);
    }
public slots:
    void doStart3()
    {
        m_pSocket3.reset( new QUdpSocket() );
    }
    void doStop3()
    {
        m_pSocket3.reset();
    }
    void writeToUdp3(const QByteArray& qBinArray)
    {
        port_large= 50012;
        retData=m_pSocket3->writeDatagram(qBinArray,QHostAddress::LocalHost, port_large);
    }
};