qt关于tcp多线程服务器

QQ：609162385
tcpserver.h

#ifndef TCPSERVER_H
#define TCPSERVER_H

#include <QTcpServer>
#include <QHash>
#include \"tcpsocket.h\"


//继承QTCPSERVER以实现多线程TCPscoket的服务器。
//如果socket的信息处理直接处理的话，很多新建的信号和槽是用不到的
class TcpServer : public QTcpServer
{
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = 0,int numConnections = 10000);
    ~TcpServer();

    void setMaxPendingConnections(int numConnections);//重写设置最大连接数函数
signals:
    void connectClient(const int , const QString & ,const quint16 );//发送新用户连接信息
    void readData(const int,const QString &, quint16, const QByteArray &);//发送获得用户发过来的数据
    void sockDisConnect(int ,QString ,quint16);//断开连接的用户信息
    void sentData(const QByteArray &,const int);//向scoket发送消息
    void sentDisConnect(int i); //断开特定连接，并释放资源，-1为断开所有。

public slots:
    void clear(); //断开所有连接，线程计数器请0
protected slots:
    void sockDisConnectSlot(int handle,const QString & ip, quint16 prot, QThread *th);//断开连接的用户信息

protected:
    void incomingConnection(qintptr socketDescriptor);//覆盖已获取多线程
private:
    QHash<int,TcpSocket *> * tcpClient;//管理连接的map
    int maxConnections;

};

#endif // TCPSERVER_H

tcpserver.cpp

#include \"tcpserver.h\"
#include \"threadhandle.h\"

TcpServer::TcpServer(QObject *parent,int numConnections) :
    QTcpServer(parent)
{
     tcpClient = new  QHash<int,TcpSocket *>;
     setMaxPendingConnections(numConnections);
}

TcpServer::~TcpServer()
{
    emit this->sentDisConnect(-1);
    delete tcpClient;
}

void TcpServer::setMaxPendingConnections(int numConnections)
{
    this->QTcpServer::setMaxPendingConnections(numConnections);//调用Qtcpsocket函数，设置最大连接数，主要是使maxPendingConnections()依然有效
    this->maxConnections = numConnections;
}

void TcpServer::incomingConnection(qintptr socketDescriptor) //多线程必须在此函数里捕获新连接
{
    if (tcpClient->size() > maxPendingConnections())//继承重写此函数后，QTcpServer默认的判断最大连接数失效，自己实现
    {
        QTcpSocket tcp;
        tcp.setSocketDescriptor(socketDescriptor);
        tcp.disconnectFromHost();
        return;
    }
    auto th = ThreadHandle::getClass().getThread();
    auto tcpTemp = new TcpSocket(socketDescriptor);
    QString ip =  tcpTemp->peerAddress().toString();
    qint16 port = tcpTemp->peerPort();

    connect(tcpTemp,&TcpSocket::sockDisConnect,this,&TcpServer::sockDisConnectSlot);//NOTE:断开连接的处理，从列表移除，并释放断开的Tcpsocket，此槽必须实现，线程管理计数也是考的他
    connect(this,&TcpServer::sentDisConnect,tcpTemp,&TcpSocket::disConTcp);//断开信号

    tcpTemp->moveToThread(th);//把tcp类移动到新的线程，从线程管理类中获取
    tcpClient->insert(socketDescriptor,tcpTemp);//插入到连接信息中
    emit connectClient(socketDescriptor,ip,port);
}

void TcpServer::sockDisConnectSlot(int handle,const QString & ip, quint16 prot,QThread * th)
{
    tcpClient->remove(handle);//连接管理中移除断开连接的socket
    ThreadHandle::getClass().removeThread(th); //告诉线程管理类那个线程里的连接断开了
    emit sockDisConnect(handle,ip,prot);
}


void TcpServer::clear()
{
    emit this->sentDisConnect(-1);
    ThreadHandle::getClass().clear();
    tcpClient->clear();
}

tcpsocket.h
#ifndef TCPSOCKET_H
#define TCPSOCKET_H

#include
#include
#include
#include
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/opencv.hpp>
#include “lensometeralgorithm.h”
#include

class TcpSocket : public QTcpSocket
{
Q_OBJECT
public:
explicit TcpSocket(qintptr socketDescriptor, QObject *parent = 0);
~TcpSocket();
QByteArray handleData(QByteArray data,const QString & ip, qint16 port);//用来处理数据的函数
void autoCorrect();
signals:
//void readData(const int,const QString &,const quint16,const QByteArray &);
void sockDisConnect(const int ,const QString &,const quint16, QThread *);//NOTE:断开连接的用户信息，此信号必须发出！线程管理类根据信号计数的
public slots:
void sentData(const QByteArray & ,const int);//发送信号的槽
void disConTcp(int i);
void dataPross();
protected slots:
void readData();//接收数据
void startNext();//处理下一个
protected:
QFutureWatcher watcher;
QQueue datas;
private:
qintptr socketID;
QMetaObject::Connection dis;
bool fileAcceptState;
QByteArray inBlock;
QByteArray imageDate;

cv::Mat oriImg;
LensometerAlgorithm pross;
classOutParam out;

};

#endif // TCPSOCKET_H

tcpsocket.cpp
#include “tcpsocket.h”
#include <QtConcurrent/QtConcurrent>
#include
#include
#include

TcpSocket::TcpSocket(qintptr socketDescriptor, QObject *parent) : //构造函数在主线程执行，lambda在子线程
QTcpSocket(parent),socketID(socketDescriptor)
{
this->setSocketDescriptor(socketDescriptor);
connect(this,&TcpSocket::readyRead,this,&TcpSocket::readData);
dis = connect(this,&TcpSocket::disconnected,
&{
qDebug() << “disconnect” ;
emit sockDisConnect(socketID,this->peerAddress().toString(),this->peerPort(),QThread::currentThread());//发送断开连接的用户信息
this->deleteLater();
});
connect(&watcher,&QFutureWatcher::finished,this,&TcpSocket::startNext);
connect(&watcher,&QFutureWatcher::canceled,this,&TcpSocket::startNext);
qDebug() << “new connect” ;
oriImg.create(960,1280,CV_8UC1);//接受图像 数据
fileAcceptState = false;
autoCorrect();
}

TcpSocket::~TcpSocket()
{
}

void TcpSocket::sentData(const QByteArray &data, const int id)
{
if(id == socketID)
{
write(data);
}
}

void TcpSocket::disConTcp(int i)
{
if (i == socketID)
{
this->disconnectFromHost();
}
else if (i == -1) //-1为全部断开
{
disconnect(dis); //先断开连接的信号槽，防止二次析构
this->disconnectFromHost();
this->deleteLater();
}
}

void TcpSocket::dataPross()
{
qDebug()<<“over”;
char midchar = (char)oriImg.data;
qDebug()<<“imageDate.size()”<<imageDate.size();
memccpy(midchar,imageDate.data(),1,imageDate.size());
pross.algorithmProcessing(oriImg.data,out);
QByteArray writeBuffer;
writeBuffer.append(QString::number(out.recordS,‘f’,2));
writeBuffer.append(\"