最近在看有关IO复用方面的内容，自己也用标准c++库实现了select模型、iocp模型、poll模型。回过头来很想了解QT的socket是基于什么模型来实现的，所以看了QT关于TcpServer实现的相关源码，现在将所了解的内容记录下来，希望对感兴趣的朋友有所帮助。
1.我们先从QTcpServer的构造函数来看，下面是QTcpServer的构造函数原型：
QTcpServer::QTcpServer(QObject *parent)
: QObject(*new QTcpServerPrivate, parent)
{
Q_D(QTcpServer);
#if defined(QTCPSERVER_DEBUG)
qDebug("QTcpServer::QTcpServer(%p)", parent);
#endif
d->socketType = QAbstractSocket::TcpSocket;
}
我们可以看到首先创建了一个QTcpServerPrivate的参数类，在QT源码中，每一个类都有一个参数类，参数类的类名是：类名+Private，这个类主要放置QTcpServer类中会使用到的一些成员对象，而QTcpServer里面只会定义方法不会有成员对象了。然后构造函数内部实现很简单：
Q_D(QTcpServer);这个宏实际上就是取到QTcpServerPrivate对象的指针赋给变量d，
d->socketType = QAbstractSocket::TcpSocket;把套接字类型设置为Tcp。
那么第一步构造函数的工作就结束了。
2. 当我们调用listen函数以后，tcpserver就启动了，之后连接，接收数据和发送数据完成都可以通过信号来接收，那么QT具体是如何实现等待连接和等待接收数据的呢，对于不同平台又是怎么实现的，我们来分析一下listen函数做了什么工作。
（1）首先判断是否已是监听状态，是的话就直接返回。
Q_D(QTcpServer);
if (d->state == QAbstractSocket::ListeningState) {
qWarning("QTcpServer::listen() called when already listening");
return false;
}
（2）设置协议类型，IP地址端口号等。
QAbstractSocket::NetworkLayerProtocol proto = address.protocol();
QHostAddress addr = address;
#ifdef QT_NO_NETWORKPROXY
static const QNetworkProxy &proxy = *(QNetworkProxy *)0;
#else
QNetworkProxy proxy = d->resolveProxy(addr, port);
#endif
delete d->socketEngine;
（3）创建socketEngine对象，socketEngine的类型是QAbstractSocketEngine，QAbstractSocketEngine定义了很多与原始套接字机制相似的函数如bind、listen、accept等方法，也实现了：waitForRead、writeDatagram、read等函数。所以可以看到我们调用QSocket的读写方法其实都是由QAbstractSocketEngine类来实现的。但是QAbstractSocketEngine本身是一个抽象类，是不能被实例化的，listen函数里面调用了QAbstractSocketEngine类的静态函数createSocketEngine来创建对象。
d->socketEngine = QAbstractSocketEngine::createSocketEngine(d->socketType, proxy, this);
if (!d->socketEngine) {
d->serverSocketError = QAbstractSocket::UnsupportedSocketOperationError;
d->serverSocketErrorString = tr("Operation on socket is not supported");
return false;
}
我们在来看一下createSocketEngine具体是怎么实现的：
QAbstractSocketEngine *QAbstractSocketEngine::createSocketEngine(QAbstractSocket::SocketType socketType, const QNetworkProxy &proxy, QObject *parent)
{
return new QNativeSocketEngine(parent);
}
这个不是完整代码，但是前面的所有条件判断完后，最终就是调用这一句返回一个QNativeSocketEngine对象，QNativeSocketEngine继承了QAbstractSocketEngine 类，实现了QAbstractSocketEngine 的所有功能，在这个类的具体代码中我们可以看到一些做平台判断的代码，也可以找到与平台相关的套接字函数，我们可以看到QNativeSocketEngine的实现不只一个文件，有qnativesocketengine_unix.cpp、qnativesocketengine_win.cpp、qnativesocketengine_winrt.cpp。所以当你在windows平台编译程序的时候编译器包含的是qnativesocketengine_win.cpp文件，在linux下编译的时候包含的是qnativesocketengine_unix.cpp文件，所以QT通过一个抽象类和不同平台的子类来实现跨平台的套接字机制。
（4）回到TcpServer的listen函数，创建socketEngine对象以后，开始调用bind,listen等函数完成最终的socket设置。
#ifndef QT_NO_BEARERMANAGEMENT
//copy network session down to the socket engine (if it has been set)
d->socketEngine->setProperty("_q_networksession", property("_q_networksession"));
#endif
if (!d->socketEngine->initialize(d->socketType, proto)) {
d->serverSocketError = d->socketEngine->error();
d->serverSocketErrorString = d->socketEngine->errorString();
return false;
}
proto = d->socketEngine->protocol();
if (addr.protocol() == QAbstractSocket::AnyIPProtocol && proto == QAbstractSocket::IPv4Protocol)
addr = QHostAddress::AnyIPv4;
d->configureCreatedSocket();
if (!d->socketEngine->bind(addr, port)) {
d->serverSocketError = d->socketEngine->error();
d->serverSocketErrorString = d->socketEngine->errorString();
return false;
}
if (!d->socketEngine->listen()) {
d->serverSocketError = d->socketEngine->error();
d->serverSocketErrorString = d->socketEngine->errorString();
return false;
}
（5）设置信号接收
d->socketEngine->setReceiver(d);
d->socketEngine->setReadNotificationEnabled(true);
setReceiver传入TcpServerPrivate对象，从函数名可以看出是设置一个接收信息的对象，所以当套接字有新信息时，就会回调TcpServerPrivate对象的相关函数来实现消息通知。设置完消息接收对象以后，调用setReadNotificationEnabled(true)来启动消息监听。这个函数的实现如下：
void QNativeSocketEngine::setReadNotificationEnabled(bool enable)
{
Q_D(QNativeSocketEngine);
if (d->readNotifier) {
d->readNotifier->setEnabled(enable);
} else if (enable && d->threadData->hasEventDispatcher()) {
d->readNotifier = new QReadNotifier(d->socketDescriptor, this);
d->readNotifier->setEnabled(true);
}
}
我们看到这个函数是创建了一个QReadNotifier对象，而QReadNotifier的定义如下：
class QReadNotifier : public QSocketNotifier
{
public:
QReadNotifier(qintptr fd, QNativeSocketEngine *parent)
: QSocketNotifier(fd, QSocketNotifier::Read, parent)
{ engine = parent; }
protected:
bool event(QEvent *) override;
QNativeSocketEngine *engine;
};
bool QReadNotifier::event(QEvent *e)
{
if (e->type() == QEvent::SockAct) {
engine->readNotification();
return true;
} else if (e->type() == QEvent::SockClose) {
engine->closeNotification();
return true;
}
return QSocketNotifier::event(e);
}
我们可以看到QReadNotifier继承了QSocketNotifier，而QSocketNotifier是一个消息处理类，主要用来监听文件描述符活动的，也就是当文件描述符状态变更时则会触发相应信息，它可以监听三种状态：Read、Write、Exception。而我们这里用到的QReadNotifier它监听的是Read事件，也就是当套接字句柄有可读消息（连接信息也是可读信息的一种）时就会回调event函数，而在event里面回调了engine->readNotification();readNotification函数的实现如下：
void QAbstractSocketEngine::readNotification()
{
if (QAbstractSocketEngineReceiver *receiver = d_func()->receiver)
receiver->readNotification();
}
engine的readNotification又回调了receiver的readNotification函数，还记得我们上面说的吗，receiver实际上就是QTcpServerPrivate，所以到这里，QT实现了当有新的客户端连接时，通知QTcpServerPrivate对象的功能，所以我们看一下QTcpServerPrivated的readNotification实现：
void QTcpServerPrivate::readNotification()
{
Q_Q(QTcpServer);
for (;;) {
if (pendingConnections.count() >= maxConnections) {
#if defined (QTCPSERVER_DEBUG)
qDebug("QTcpServerPrivate::_q_processIncomingConnection() too many connections");
#endif
if (socketEngine->isReadNotificationEnabled())
socketEngine->setReadNotificationEnabled(false);
return;
}
int descriptor = socketEngine->accept();
if (descriptor == -1) {
if (socketEngine->error() != QAbstractSocket::TemporaryError) {
q->pauseAccepting();
serverSocketError = socketEngine->error();
serverSocketErrorString = socketEngine->errorString();
emit q->acceptError(serverSocketError);
}
break;
}
#if defined (QTCPSERVER_DEBUG)
qDebug("QTcpServerPrivate::_q_processIncomingConnection() accepted socket %i", descriptor);
#endif
q->incomingConnection(descriptor);
QPointer<QTcpServer> that = q;
emit q->newConnection();
if (!that || !q->isListening())
return;
}
}
我们可以看到这个函数里面调用了socketEngine->accept();获取套接字句柄，然后传给q->incomingConnection(descriptor);创建QTcoSocket对象，最后发送emit q->newConnection();信号，这个信号有用过QTcpServer的应该就很熟悉了吧，所以QT通过内部消息机制实现了套接字的异步通信，而对外提供的函数即支持同步机制也支持异步机制，调用者可以选择通过信号槽机制来实现异步，也可以调用如：waitforread,waitforconnect等函数来实现同步等待，实际上waitforread等同步函数是通过函数内部的循环来检查消息标志，当标志为可读或者函数超时时则返回。
3.QSocketNotifier的实现
我们在上面说了通过QSocketNotifier，我们可以实现当套接字有可读或可写信号时调用event函数来实现异步通知。但是QSocketNotifier又是如何知道socket什么时候发生变化的呢。QSocketNotifier的实现和QT的消息处理机制是息息相关的，要完全讲清楚就必须讲到QT的消息机制，这个已经超出对QTcpServer的讨论了，当然我们还是可以把其中比较关键的代码抽取出来分析一下。首先不同平台的消息处理机制都是不一样的，所以QSocketNotifier在不同平台下的实现也是不一样的，我们首先来看一下windows平台下是如何实现的。
（1）注册SocketNotifier
QSocketNotifier::QSocketNotifier(qintptr socket, Type type, QObject *parent)
: QObject(*new QSocketNotifierPrivate, parent)
{
Q_D(QSocketNotifier);
d->sockfd = socket;
d->sntype = type;
d->snenabled = true;
if (socket < 0)
qWarning("QSocketNotifier: Invalid socket specified");
else if (!d->threadData->eventDispatcher.load())
qWarning("QSocketNotifier: Can only be used with threads started with QThread");
else
d->threadData->eventDispatcher.load()->registerSocketNotifier(this);
}
我们看到QSocketNotifier的构造函数里面需要传入socket句柄以及要监听的类型，read,write或者error。然后调用了QSocketNotifierPrivate的registerSocketNotifier函数把自己注册进去，这使得当有消息触发的时候可以调用这个对象的event函数。
（2）调用WSAAsyncSelect
在registerSocketNotifier函数里面会调用WSAAsyncSelect函数，这个函数的原型是：int PASCAL FAR WSAAsyncSelect (SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);
s 要监听的套接字句柄
hWnd 标识一个在网络事件发生时需要接收消息的窗口句柄.
wMsg 在网络事件发生时要接收的消息.
lEvent位屏蔽码，用于指明应用程序感兴趣的网络事件集合.
这个函数的作用是告诉操作系统当套接字发送改变时，发送一条消息给我们的应用程序，发送的消息内容就是我们传入的wMsg，QT在调用的时候传入了一个消息类型WM_QT_SOCKETNOTIFIER，所以当我们的应用程序接收到系统返回的WM_QT_SOCKETNOTIFIER类型的消息我们就知道是有某个套接字状态改变了。
（3）qt_internal_proc
qt_internal_proc是消息回调函数，当系统发送消息给程序后，会进入这个处理函数，在其中有一段代码用于处理WM_QT_SOCKETNOTIFIER消息的代码：
if (message == WM_QT_SOCKETNOTIFIER) {
// socket notifier message
int type = -1;
switch (WSAGETSELECTEVENT(lp)) {
case FD_READ:
case FD_ACCEPT:
type = 0;
break;
case FD_WRITE:
case FD_CONNECT:
type = 1;
break;
case FD_OOB:
type = 2;
break;
case FD_CLOSE:
type = 3;
break;
}
if (type >= 0) {
Q_ASSERT(d != 0);
QSNDict *sn_vec[4] = { &d->sn_read, &d->sn_write, &d->sn_except, &d->sn_read };
QSNDict *dict = sn_vec[type];
QSockNot *sn = dict ? dict->value(wp) : 0;
if (sn == nullptr) {
d->postActivateSocketNotifiers();
} else {
Q_ASSERT(d->active_fd.contains(sn->fd));
QSockFd &sd = d->active_fd[sn->fd];
if (sd.selected) {
Q_ASSERT(sd.mask == 0);
d->doWsaAsyncSelect(sn->fd, 0);
sd.selected = false;
}
d->postActivateSocketNotifiers();
const long eventCode = WSAGETSELECTEVENT(lp);
if ((sd.mask & eventCode) != eventCode) {
sd.mask |= eventCode;
QEvent event(type < 3 ? QEvent::SockAct : QEvent::SockClose);
QCoreApplication::sendEvent(sn->obj, &event);
}
}
}
return 0;
}
这段代码的功能主要是检查事件类型，然后查询是哪个句柄的事件，通过句柄与事件类型可以关联到我们注册的对象，然后调用QCoreApplication::sendEvent给我们的对象发送事件，在这个函数里最终就是调用到QSocketNotifier的event函数。至此整个套接字从应用层到QT底层到系统API的整个流程就很清楚了。所以我们可以看到QT是通过WSAAsyncSelect来实现IO复用的，相比于select模型，这种模型是异步的，而且没有监听数量的上限。
讲完了windows平台的，我们在来看一下linux平台下的实现，第一步和windows的一样都是在QSocketNotifier构造函数里面注册对象本身用于接收事件。
（1）registerSocketNotifier
在这个函数里面主要是将对象和套接字句柄作为映射放入socketNotifiers里面。
QHash<int, QSocketNotifierSetUNIX> socketNotifiers;
（2）processEvents
这个函数是用于处理所有消息的，在这其中一段用于处理套接字相关
switch (qt_safe_poll(d->pollfds.data(), d->pollfds.size(), tm)) {
case -1:
perror("qt_safe_poll");
break;
case 0:
break;
default:
nevents += d->threadPipe.check(d->pollfds.takeLast());
if (include_notifiers)
nevents += d->activateSocketNotifiers();
break;
}
（3）qt_safe_poll
qt_safe_poll调用了qt_ppoll，而qt_ppoll里面是如此定义的：
static inline int qt_ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout_ts)
{
#if QT_CONFIG(poll_ppoll) || QT_CONFIG(poll_pollts)
return ::ppoll(fds, nfds, timeout_ts, nullptr);
#elif QT_CONFIG(poll_poll)
return ::poll(fds, nfds, timespecToMillisecs(timeout_ts));
#else
return qt_poll(fds, nfds, timeout_ts);
#endif
}
这里可以通过QT_CONFIG的标志判断来采取其中一种实现，qt_poll是QT自己实现的函数，实际上采用的是select模式，在早期的版本中应该是用的select模式，QT5.7以后的版本采用了poll模式，我所用的版本是QT5.9用的就是poll模式，之所以使用poll取代select是因为select模式监听的套接字长度是用的定长的数组，所以在运行期是无法扩展的，只要套接字超过FD_SETSIZE就会返回错误，在Linux默认的设置中FD_SETSIZE为1024。
（4）activateSocketNotifiers
在processEvents函数中调用了qt_safe_poll来检查是否有套接字事件，如果有事件需要处理则调用activateSocketNotifiers函数，而这个函数中调用了QCoreApplication::sendEvent(notifier, &event);将消息回馈给QSocketNotifier。到此linux下的socket完整流程我们也知道了，在linux下可能采用select或者poll来实现io复用，具体要看你使用的版本。