Многопоточный TCP client (QThread и QTcpSocket)

#include <QObject>
#include <QThread>
#include <QTcpSocket>
 
class THREAD : public QThread
{
    Q_OBJECT
public:
 THREAD(QObject *parent = 0);
~THREAD();
 
 void run();
 void start();
 
public slots:
    void WRITE();
    void READ();
    void ERR();
signals:
    void RE_WRITE();
   // void START();
 
public:
 
    QTcpSocket reg;
    int i;
    int g;
    char A[6666];
 
private:
 bool quit;
};
 
#endif // THREAD_H

#include "thread.h"
 
class Sleeper: public QThread
{
public:
    static void msleep(int ms)
    {
        QThread::msleep(ms);
    }
};
 
 
THREAD::THREAD(QObject *parent)
    : QThread(parent), quit(false)
{
}
 
THREAD::~THREAD()
{
 
    wait();
}
 
void THREAD::run()
{
 
 
    QObject::connect(&reg, SIGNAL(connected()),this, SLOT(WRITE())); // после подключения запрс
 
    QObject::connect(&reg, SIGNAL(readyRead()), this, SLOT(READ())); // считывание 
 
    QObject::connect(this, SIGNAL(RE_WRITE()), this, SLOT(WRITE())); // и опять запрос
 
    QObject::connect(&reg, SIGNAL(disconnected()), this, SLOT(ERR())); // при сбое переподключаемся
 
    start();
}
 
 
void THREAD::WRITE()
{
    reg.write("Hello!!!", 8);   // для запроса серверу нужно 8 байт отослать
    g=0;
    i=0;
}
 
void THREAD::READ()
{
 
    memset(A,0,sizeof(A));
 
   i=reg.read(A,reg.bytesAvailable());
    g=g+i;
//   qDebug() << g << endl;
//   qDebug() << i << endl;
 
    //
 
    if( g>=6666)
    {
        Sleeper::msleep(500);
        emit RE_WRITE();
    }
}
 
void THREAD::ERR()
{
    reg.close();
    Sleeper::msleep(3000);
    reg.connectToHost("192.168.50.50", 5000);
}
 
void THREAD::start()
{
    reg.connectToHost("192.168.50.50", 5000);
}

 QApplication a(argc, argv);
    Wind w;
    Wind.show();
    
THREAD T;
T.run();
 
    return a.exec();

    memset(A,0,sizeof(A));
 
   i=reg.read(A,reg.bytesAvailable());
    g=g+i;

 char buffer[1024]
   i=reg.readLine(buffer,sizeof(buffer));
    if(i !=-1){emit new_data(buffer)}

class ThreadSocket : public QThread
{
    Q_OBJECT
public:
    ThreadSocket(QString& iqstr_Address, int iint_Port, QObject* parent = 0);
    ~ThreadSocket();
private:
    bool mboo_Connected;
    QTcpSocket* mpqtcp_Socket;
    QString mqstr_Address;
    int mint_Port;
 
    QByteArray buffer;
 
signals:
    void Sign_RecMsg(QByteArray);
 
public slots:
    void run();
    void Disconnect();
    void SendUpdate(QByteArray iqstr);
private slots:
    void SocketConnected();
    void SocketAnswer();
    void SocketError(int iint_Error);
    void SocketClosed();
 
 
};

ThreadSocket::ThreadSocket(QString& iqstr_Address, int iint_Port, QObject* parent)
    :QThread(parent), mqstr_Address(iqstr_Address), mint_Port(iint_Port)
{
    i = 0;
    mboo_Connected = false;
}
 
ThreadSocket::~ThreadSocket()
{
    mpqtcp_Socket->close();
    delete mpqtcp_Socket;
}
 
void ThreadSocket::run()
{
    mpqtcp_Socket = new QTcpSocket(this);
    //mpqtcp_Socket->moveToThread(new QThread);
 
    connect (mpqtcp_Socket, SIGNAL (connected()), SLOT(SocketConnected()) );
    //connect (mpqtcp_Socket, SIGNAL (connectionClosed()), SLOT(SocketClosed()), Qt::DirectConnection );
    connect (mpqtcp_Socket, SIGNAL (disconnected()), SLOT(SocketClosed()));
 
    connect (mpqtcp_Socket, SIGNAL (readyRead()), SLOT(SocketAnswer()), Qt::DirectConnection);
    //connect (mpqtcp_Socket, SIGNAL (er(int)), SLOT(SocketError(int)) );
 
    mpqtcp_Socket->connectToHost (mqstr_Address, mint_Port);
 
 
    //exec();
}
 
void ThreadSocket::SendUpdate(QByteArray iqstr_SendLine)
{
    qint64 lqint_Ret;
    while (mboo_Connected == false) {
        msleep(100);
    }
    lqint_Ret = mpqtcp_Socket->write(iqstr_SendLine.data(), iqstr_SendLine.size());
 
    if (mpqtcp_Socket->waitForBytesWritten(1000)) {
        // aspetta la fine dell'invio stringa
    }
}
 
void ThreadSocket::SocketConnected()
{
    mboo_Connected = true;
}
 
void ThreadSocket::SocketAnswer()
{
    qint64 lqint_Length;
 
 
    char buffer[1024];
    while (mpqtcp_Socket->canReadLine()) {
 
        lqint_Length = mpqtcp_Socket->readLine(buffer, sizeof(buffer));
        if (lqint_Length != -1) {
            emit Sign_RecMsg(QByteArray(buffer));
        }
        strcpy(buffer, "");
    }
}
 
void ThreadSocket::SocketError(int iint_Error)
{
    int c = iint_Error;
}
 
void ThreadSocket::SocketClosed()
{
 
}
 
void ThreadSocket::Disconnect()
{
    mpqtcp_Socket->disconnectFromHost();
    mpqtcp_Socket->waitForDisconnected();
}

    ThreadSocket* socket = new ThreadSocket(addr,1234);
    connect(this,SIGNAL(socketUp()),socket,SLOT(run()));
    connect(socket,SIGNAL(Sign_RecMsg(QByteArray)),this,SLOT(newData(QByteArray)));
    connect(this,SIGNAL(toWrite(QByteArray)),socket,SLOT(SendUpdate(QByteArray)));

T.run();

T.start();

#include <QObject>
#include <QThread>
#include <QTcpSocket>
 
class THREAD : public QThread
{
    Q_OBJECT
public:
 THREAD(QObject *parent = 0);
~THREAD();
 
 void run();
 
 
public slots:
    void WRITE();
    void READ();
    void ERR();
    void SL_RUN();
signals:
    void RE_WRITE();
    void RE_START();
    void SG_RUN();
 
public:
 
    QTcpSocket reg;
    int i;
    int g;
 
    char A[6666];
 
private:
 bool quit;
};
 
#endif // THREAD_H
 
//===================================================
 
 
#include "thread.h"
 
class Sleeper: public QThread
{
public:
    static void msleep(int ms)
    {
        QThread::msleep(ms);
    }
};
 
 
THREAD::THREAD(QObject *parent)
    : QThread(parent), quit(false)
{
}
 
THREAD::~THREAD()
{
 
    wait();
}
 
void THREAD::run()
{
 
   // reg=new QTcpSocket(this);
 
    QObject::connect(this, SIGNAL(SG_RUN()),this, SLOT(SL_RUN()));            // коннект
 
    QObject::connect(&reg, SIGNAL(connected()),this, SLOT(WRITE()));        // запрос
 
    QObject::connect(&reg, SIGNAL(readyRead()), this, SLOT(READ()));         // чтение
 
    QObject::connect(this, SIGNAL(RE_WRITE()), this, SLOT(WRITE()));         // повторный запрос
 
    QObject::connect(&reg, SIGNAL(disconnected()), this, SLOT(ERR()));       // случайное отключение 
 
    QObject::connect(this, SIGNAL(RE_START()), this, SLOT(ERR()));            // на случай ошибки
 
    emit SG_RUN();
 
    exec();
}
 
 
void THREAD::WRITE()
{
    reg.write("Hello!!!", 8);
    g=0;
    i=0;
}
 
void THREAD::READ()
{
    char  B[6666];
    memset(B,0,sizeof(B));
 
   i=reg.read(B,reg.bytesAvailable());
//qDebug() << i << endl;
   g=g+i;
 
   if( g>=6666)
   {
   Sleeper::msleep(500);
   emit RE_WRITE();
   }
 
/*   Так у меня будет работать сборка посылки == не по ReadLine
    if(i<0)
    {
    emit RE_START();
    }
    else if((i>=0)&&(g<6666))
    {
 
        memcpy(&A[g],B,i);
        g=g+i;
      //  qDebug() << i << endl;
 
        if( g==6666)
        {
        Sleeper::msleep(500);
        emit RE_WRITE();
        }
    }
    else
    {
    emit RE_START();
    }
*/
}
 
void THREAD::ERR()
{
    reg.close();
    Sleeper::msleep(3000);
    emit SG_RUN();
}
 
void THREAD::SL_RUN()
{
 
reg.connectToHost("192.168.50.50", 5000);
}

myPushButton::onClick(){
socket->write("send someone");
}
будет подвешивать гуй

ThreadSocket* socket = new ThreadSocket(addr,1234);
    connect(this,SIGNAL(socketUp()),socket,SLOT(run()));
    connect(socket,SIGNAL(Sign_RecMsg(QByteArray)),this,SLOT(newData(QByteArray)));
    connect(this,SIGNAL(toWrite(QByteArray)),socket,SLOT(SendUpdate(QByteArray)));
emit socketUp();
]

class Sleeper: public QThread
{
public:
    static void msleep(int ms)
    {
        QThread::msleep(ms);
    }
};

connect(&timer,SIFNAL(timeout()),this,SLOT(getData(){/*ваша реализация*/}));

где-то в заголовке и конструкторе класса
bool locker = false;
 
void paintData(){
if(locker){
return;
}
locker = true;
 
//некоторые действия над виджетами
 
locker = false;
}

//в заголовочном файле
QMutex locker;
 
void paintData(){
QMutexLocker(&lock);
//работа над виджетами
}

//класс занимающийся обработкой(к примеру ваш UI)
//В заголовке
QList list;
 
 
void slotSaveData(someData){
list.append(someData)
}
 
//а вот теперь таймером из гуя можно получать эти данные
 
connect(&timer,timeout(),...,slotGetData());
 
 
void slotGetData(){
emit newData(list);
list.clear();
}