7种网络编程I/O模型代码实现实例

部分代码参考《[WINDOWS网络与通信程序设计].王艳平》，网络中一些I/O模型的代码都没有对socket是否可写做过深入研究，我这边会提供一些解决方法。
阻塞模式下，send会发生阻塞（非阻塞模式下send返回WSAEWOULDBLOCK错误，重叠I/O下表现为投递的发送请求一直无法完成）的情况一般可以分为3种 :
1, 服务器虽然发送了大量数据，但客户端并未调用recv函数去接。
2，网络状况不佳，发送缓冲区中的数据一直发不出去。
3，发送数据量很大，如下载功能，协议发送数据的速度比不上send函数将数据拷贝到发送缓冲区的速度。
对于1,2情况，我们似乎可以直接关闭套接字，让客户端重新请求。但对于3，却不行。而且实际操作过程中，我们无法区分是1,2,还是3，我们能做的是尽量去保证发送的正确性。当然防止1情况或者2情况中长时间网络不畅，可以设定超时。若socket一直处于不可写状态超过1分钟，那么就关闭套接字。在最后的IOCP模型中就加入了这种超时机制。其他模型若要加入，可参考它来做。

一，基本的阻塞模型
[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>

#pragma comment(lib,"Ws2_32.lib")

DWORD WINAPI WorkThread(void* param)
{
SOCKET* psClient = (SOCKET*)param;
char buf[4096];
while(true)
{
int len = recv(*psClient,buf,4096,0);
if(len <= 0)
{
printf("recv失败！%d\n",WSAGetLastError());
Sleep(5000);
break;
}
buf[len] = '\0';
printf("收到数据：%s\n",buf);
}
closesocket(*psClient);
delete psClient;
return 0;
}

int main()
{
WSAData wsaData;
if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))
{
printf("WSAStartup失败！\n",WSAGetLastError());
Sleep(5000);
return 0;
}
USHORT nPort = 3456;
SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nPort);
sin.sin_addr.S_un.S_addr = INADDR_ANY;

if(SOCKET_ERROR == ::bind(sListen,(sockaddr*)&sin,sizeof(sin)))
{
printf("bind失败！%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}

::listen(sListen,5);

while(true)
{
sockaddr_in addrRemote;
int nAddrLen = sizeof(addrRemote);
SOCKET *psClient = new SOCKET;
*psClient = accept(sListen,(sockaddr*)&addrRemote,&nAddrLen);
HANDLE hThread = CreateThread(NULL,0,WorkThread,psClient,0,NULL);
CloseHandle(hThread);
}
closesocket(sListen);
WSACleanup();
}

二，无任何优化的非阻塞模型
[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>
#include <vector>
using namespace std;

#pragma comment(lib,"Ws2_32.lib")

CRITICAL_SECTION g_cs;
HANDLE g_StartEvent;
vector<SOCKET> g_vecClients;
int g_iVecSize = 0;
DWORD WINAPI WorkThread(void* param)
{
char buf[4096];
while(1)
{
if(g_vecClients.empty())
{
ResetEvent(g_StartEvent);
WaitForSingleObject(g_StartEvent,INFINITE);
}

EnterCriticalSection(&g_cs);
for(vector<SOCKET>::iterator it = g_vecClients.begin();it != g_vecClients.end();)
{
int len = recv(*it,buf,4096,0);
if(len == SOCKET_ERROR)
{
if(WSAEWOULDBLOCK != WSAGetLastError())
{
printf("recv Error:%d\n",WSAGetLastError());
closesocket(*it);
it = g_vecClients.erase(it);
}
else
{
printf("%d.",*it);
++it;
}
}
else
{
buf[len] = 0;
printf("收到数据: %s\n",buf);
++it;
}
}
LeaveCriticalSection(&g_cs);
Sleep(100);

}
return 0;
}

int main()
{
InitializeCriticalSectionAndSpinCount(&g_cs,4000);
g_StartEvent = CreateEvent(NULL,FALSE,FALSE,NULL);

WSAData wsaDate;
WSAStartup(MAKEWORD(2,2),&wsaDate);
USHORT nport = 3456;
u_long ul = 1;
SOCKET s = socket(AF_INET,SOCK_STREAM,0);
ioctlsocket(s,FIONBIO,&ul);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.S_un.S_addr = ADDR_ANY;

if(SOCKET_ERROR == ::bind(s,(sockaddr*)&sin,sizeof(sin)))
{
return -1;
}

::listen(s,5);

HANDLE hThread = CreateThread(NULL,0,WorkThread,NULL,0,NULL);
CloseHandle(hThread);

while(true)
{
sockaddr_in addrRemote;
int nAddrLen = sizeof(addrRemote);
SOCKET sClient = accept(s,(sockaddr*)&addrRemote,&nAddrLen);
if(sClient != SOCKET_ERROR)
{
EnterCriticalSection(&g_cs);
g_vecClients.push_back(sClient);
LeaveCriticalSection(&g_cs);
if(g_vecClients.size() == 1)
SetEvent(g_StartEvent);
}
else if(WSAEWOULDBLOCK == WSAGetLastError())
{
printf(".");
Sleep(100);
}
else
{
printf("accept failed! %d\n",WSAGetLastError());
}
}
closesocket(s);
WSACleanup();
CloseHandle(g_StartEvent);
DeleteCriticalSection(&g_cs);
}

三，select模型

[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <MSWSock.h>
#include <stdio.h>
#include <map>
using namespace std;


#pragma comment(lib,"Ws2_32.lib")
#pragma comment(lib,"Mswsock.lib")


struct ThreadObj{
OVERLAPPED *pOl;
HANDLE s;
};


int g_iIndex = 0;
map<SOCKET,char*> g_map;


int main()
{
WSAData wsaData;
if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))
{
printf("初始化失败!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}
USHORT nport = 3456;
SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
u_long ul = 1;
ioctlsocket(sListen,FIONBIO,&ul);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.S_un.S_addr = ADDR_ANY;


if(SOCKET_ERROR == bind(sListen,(sockaddr*)&sin,sizeof(sin)))
{
printf("bind failed!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}


listen(sListen,5);


//1)初始化一个套接字集合fdSocket，并将监听套接字放入
fd_set fdSocket;
FD_ZERO(&fdSocket);
FD_SET(sListen,&fdSocket);
TIMEVAL time={1,0};
char buf[4096];
fd_set fdWrite;
FD_ZERO(&fdWrite);
while(true)
{
//2）将fdSocket的一个拷贝fdRead传给select函数
fd_set fdRead = fdSocket;
fd_set fdTmp = fdWrite;
int nRetAll = 0;
if(fdTmp.fd_count > 0)
nRetAll = select(0,&fdRead,&fdTmp,NULL,NULL/*&time*/);//若不设置超时则select为阻塞
else
nRetAll = select(0,&fdRead,NULL,NULL,NULL/*&time*/);
if(nRetAll > 0)
{
//3）通过将原来的fdSocket和被select处理过的fdRead进行比较，决定由哪些socket有数据可以读取
for(int i=0;i<fdSocket.fd_count;i++)
{
if(FD_ISSET(fdSocket.fd_array[i],&fdRead))
{
if(fdSocket.fd_array[i] == sListen)
{
if(fdSocket.fd_count < FD_SETSIZE)
{
sockaddr_in addrRemote;
int nAddrLen = sizeof(addrRemote);
SOCKET sClient = accept(sListen,(sockaddr*)&addrRemote,&nAddrLen);
FD_SET(sClient,&fdSocket);
printf("接收到连接：(%s)\n",inet_ntoa(addrRemote.sin_addr));
}
else
{
printf("连接数量已达上限！\n");
continue;
}
}
else
{
int nRecv = recv(fdSocket.fd_array[i],buf,4096,0);
if(nRecv > 0)
{
buf[nRecv] = 0;

printf("收到数据：%s\n",buf);

int nRet = send(fdSocket.fd_array[i],buf,nRecv,0);
if(nRet <= 0)
{
SOCKET s = fdSocket.fd_array[i];
if(GetLastError() == WSAEWOULDBLOCK)
{
if(g_map.find(s) == g_map.end())
{
char* szTmp = new char[nRecv + 1];
strncpy(szTmp,buf,nRecv);
szTmp[nRecv] = 0;
g_map[s] = szTmp;
}
else
{
char* szOld = g_map[s];
char* szTmp2 = new char[strlen(szOld) + nRecv + 1];
strncpy(szTmp2,szOld,strlen(szOld));
strncpy(szTmp2 + strlen(szOld),buf,nRecv);
szTmp2[strlen(szOld) + nRecv] = 0;
delete [] szOld;
g_map[s] = szTmp2;
}
FD_SET(fdSocket.fd_array[i],&fdWrite);
}
else
{
closesocket(fdSocket.fd_array[i]);
if(g_map.find(s) != g_map.end())
{
if(g_map[s] != NULL)
delete [] g_map[s];
g_map.erase(s);
}
FD_CLR(fdSocket.fd_array[i],&fdSocket);
}
}
printf("发送了%d\n",nRet);
}
else
{
printf("1个Client已断开\n");
closesocket(fdSocket.fd_array[i]);
FD_CLR(fdSocket.fd_array[i],&fdSocket);
}
}
}
if(FD_ISSET(fdSocket.fd_array[i],&fdTmp))
{
SOCKET s = fdSocket.fd_array[i];
if(g_map.find(s) != g_map.end())
{
char* szToSend = g_map[s];
int nToSend = strlen(szToSend);
int nRet = send(fdSocket.fd_array[i],szToSend,nToSend,0);
if(nRet <= 0)
{
if(GetLastError() == WSAEWOULDBLOCK)
{
//do nothing
}
else
{
closesocket(fdSocket.fd_array[i]);
if(g_map.find(s) != g_map.end())
{
if(g_map[s] != NULL)
delete [] g_map[s];
g_map.erase(s);
}
FD_CLR(fdSocket.fd_array[i],&fdSocket);
}
}
else if(nRet < nToSend)
{
printf("发送了%d/%d\n",nRet,nToSend);
nToSend -= nRet;
char* szTmp = new char[nToSend + 1];
strncpy(szTmp,szToSend + nRet,nToSend);
szTmp[nToSend] = 0;
delete [] szToSend;
g_map[s] = szTmp;
}
else
{
if(g_map[s] != NULL)
delete [] g_map[s];
g_map.erase(s);
FD_CLR(fdSocket.fd_array[i],&fdWrite);
}
printf("============================================发送了%d\n",nRet);
}
}
}
}
else if(nRetAll == 0)
{
printf("time out!\n");
}
else
{
printf("select error!%d\n",WSAGetLastError());
Sleep(5000);
break;
}
}
closesocket(sListen);
WSACleanup();
}

四，异步选择模型
注意：收到FD_Write消息有2种情况：1，在socket第一次和窗口句柄绑定后。2，socket从不可写状态变成可写状态。下面的事件选择模型也是同理。
[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>
#include <map>
using namespace std;


#pragma comment(lib,"Ws2_32.lib")


#define WM_SOCKET (WM_USER + 100)


map<SOCKET,char*> g_map;
LRESULT WINAPI WindowProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch(uMsg)
{
case WM_SOCKET:
{
SOCKET s = wParam;
if(WSAGETSELECTERROR(lParam))
{
printf("消息错误！\n");
closesocket(s);
return 0;
}


switch(WSAGETSELECTEVENT(lParam))
{
case FD_ACCEPT:
{
sockaddr_in addrRemote;
int nAddrLen = sizeof(addrRemote);
SOCKET sClient = accept(s,(sockaddr*)&addrRemote,&nAddrLen);
WSAAsyncSelect(sClient,hwnd,WM_SOCKET,FD_READ | FD_WRITE | FD_CLOSE);
}break;
case FD_WRITE:
{
printf("write====================\n");
if(!g_map.empty())
{
char* buf = g_map[s];
int nLenth = strlen(buf);
while(nLenth > 0)
{
int nRet = send(s,buf,nLenth,0);
if(nRet > 0)
{
buf += nRet;
nLenth -= nRet;
}
else if(10035 == GetLastError())
{
char* newBuf = new char[nLenth + 1];
strncpy(newBuf,buf,nLenth);
newBuf[nLenth] = 0;
delete [] g_map[s];
g_map[s] = newBuf;
break;
}
else
{
delete [] g_map[s];
g_map.erase(s);
closesocket(s);
}
}
if(nLenth == 0)
{
g_map.erase(s);
}
}
}break;
case FD_READ:
{
char buf[4096];
int nRet = recv(s,buf,4096,0);
if(nRet > 0)
{
buf[nRet] = 0;
//printf("收到数据：%s\n",buf);
int x = send(s,buf,nRet,0);
printf("已发送字节数：%d , 线程号：%d\n",x,GetCurrentThreadId());
if(x < 0)
{
int iError = GetLastError();
printf("数据:%s ,错误：%d\n",buf,iError);
if(10035 == iError)
{
if(g_map.end() != g_map.find(s))
{
int newLength = strlen(g_map[s]) + strlen(buf);
char* newBuf = new char[newLength + 1];
strncpy(newBuf,g_map[s],strlen(g_map[s]));
strncpy(newBuf+strlen(g_map[s]),buf,strlen(buf));
newBuf[newLength] = 0;
delete [] g_map[s];
g_map[s] = newBuf;
}
else
{
char* newBuf = new char[strlen(buf) + 1];
strncpy(newBuf,buf,strlen(buf));
newBuf[strlen(buf)] = 0;
g_map[s] = newBuf;
}
}
else
{
if(g_map.end() != g_map.find(s))
{
delete [] g_map[s];
g_map.erase(s);
}
closesocket(s);
}
}
}
else
{
printf("1个Client已经断开1111！\n");
if(g_map.end() != g_map.find(s))
{
delete [] g_map[s];
g_map.erase(s);
}
closesocket(s);
}
}break;
case FD_CLOSE:
{
printf("1个Client已经断开222！\n");
if(g_map.end() != g_map.find(s))
{
delete [] g_map[s];
g_map.erase(s);
}
closesocket(s);
}break;
}
}break;
case WM_DESTROY:
{
printf("窗口已关闭！\n");
PostQuitMessage(0);
}
}
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}


int main()
{
char szClassName[] = "WSAAsyncSelect Test";
static WNDCLASSEX wndClass;
wndClass.cbSize = sizeof(wndClass);
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = WindowProc;
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = GetModuleHandle(0);
wndClass.hIcon = LoadIcon(NULL,IDI_APPLICATION);
wndClass.hCursor = LoadCursor(NULL,IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = szClassName;
wndClass.hIconSm = NULL;


ATOM atom = RegisterClassEx(&wndClass);
if(0 == atom)
{
char error[256];
sprintf(error,"RegisterClassEx错误！%d",GetLastError());
MessageBox(NULL,error,"error",MB_OK);
return -1;
}
HWND hwnd = CreateWindowEx(0,(char *)atom,"",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
CW_USEDEFAULT,CW_USEDEFAULT,HWND_MESSAGE,NULL,NULL,NULL);
if(hwnd == NULL)
{
char error[256];
sprintf(error,"创建窗口错误！%d",GetLastError());
MessageBox(NULL,error,"error",MB_OK);
return -1;
}


WSAData wsaData;
if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))
{
printf("初始化失败!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}
USHORT nport = 3456;
SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.S_un.S_addr = ADDR_ANY;


if(SOCKET_ERROR == bind(sListen,(sockaddr*)&sin,sizeof(sin)))
{
printf("bind failed!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}


WSAAsyncSelect(sListen,hwnd,WM_SOCKET,FD_ACCEPT | FD_CLOSE);
listen(sListen,5);


MSG msg;
while(GetMessage(&msg,NULL,0,0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
closesocket(sListen);
WSACleanup();
return msg.wParam;
}

五，事件选择模型
事件选择模型主要难点是对线程池的使用，send操作可以参考异步选择模型。
[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <stdio.h>
#include <vector>
using namespace std;


#pragma comment(lib,"Ws2_32.lib")


typedef struct _THREAD_OBJ
{
HANDLE events[WSA_MAXIMUM_WAIT_EVENTS];
SOCKET sockets[WSA_MAXIMUM_WAIT_EVENTS];
int nSocksUsed;
CRITICAL_SECTION cs;
_THREAD_OBJ *pNext;
}THREAD_OBJ,*PTHREAD_OBJ;


PTHREAD_OBJ g_pThreadList = NULL;
CRITICAL_SECTION g_cs;
BOOL g_bServerRunning = FALSE;
HANDLE g_hThreads[1000] = {0};
int g_nThreadsCount = 0;


PTHREAD_OBJ CreateThreadObj()
{
PTHREAD_OBJ pThread = new THREAD_OBJ();
if(pThread != NULL)
{
InitializeCriticalSectionAndSpinCount(&pThread->cs,4000);
pThread->events[0] = WSACreateEvent();
pThread->nSocksUsed = 1;
EnterCriticalSection(&g_cs);
pThread->pNext = g_pThreadList;
g_pThreadList = pThread;
LeaveCriticalSection(&g_cs);
}
return pThread;
}


void FreeThreadObj(PTHREAD_OBJ pThread)
{
if(pThread == NULL)
return;
EnterCriticalSection(&g_cs);
PTHREAD_OBJ p = g_pThreadList;
if(p == pThread)
{
g_pThreadList = p->pNext;
}
else
{
while(p != NULL && p->pNext != pThread)
{
p = p->pNext;
}
if(p != NULL)
{
p->pNext = pThread->pNext;
}
}
LeaveCriticalSection(&g_cs);


DeleteCriticalSection(&pThread->cs);
WSACloseEvent(pThread->events[0]);
delete pThread;
}


LONG g_nTotalConnections;
LONG g_nCurrentConnections;


BOOL InsertSocket(PTHREAD_OBJ pThread,SOCKET s)
{
if(pThread == NULL || s == INVALID_SOCKET)
return FALSE;


BOOL bRet = FALSE;
EnterCriticalSection(&pThread->cs);
if(pThread->nSocksUsed < WSA_MAXIMUM_WAIT_EVENTS)
{
pThread->events[pThread->nSocksUsed] = WSACreateEvent();
pThread->sockets[pThread->nSocksUsed] = s;
WSAEventSelect(s,pThread->events[pThread->nSocksUsed],FD_READ | FD_CLOSE | FD_WRITE);
pThread->nSocksUsed++;
bRet = TRUE;
WSASetEvent(pThread->events[0]);//通知线程，有新的事件加入了，需要重新调用WSAWaitFormultipleEvents
}
LeaveCriticalSection(&pThread->cs);


if(bRet)
{
InterlockedIncrement(&g_nTotalConnections);
InterlockedIncrement(&g_nCurrentConnections);
}
return bRet;
}


void RemoveSocket(PTHREAD_OBJ pThread,SOCKET s)
{
if(pThread == NULL || s == INVALID_SOCKET)
return;
EnterCriticalSection(&pThread->cs);
for(int i=1;i<pThread->nSocksUsed;i++)
{
if(pThread->sockets[i] == s)
{
WSACloseEvent(pThread->events[i]);
closesocket(s);
for(int j=i;j<pThread->nSocksUsed - 1;j++)
{
pThread->events[j] = pThread->events[j+1];
pThread->sockets[j] = pThread->sockets[j+1];
}
pThread->nSocksUsed--;
break;
}
}
LeaveCriticalSection(&pThread->cs);
InterlockedDecrement(&g_nCurrentConnections);
}


BOOL HandleIo(PTHREAD_OBJ pThread,int nIndex)
{
WSANETWORKEVENTS event;
SOCKET s = pThread->sockets[nIndex];
HANDLE sEvent = pThread->events[nIndex];
if(0 != WSAEnumNetworkEvents(s,sEvent,&event))
{
printf("socket error!\n");
RemoveSocket(pThread,s);
return FALSE;
}
do
{
if(event.lNetworkEvents & FD_READ)
{
if(event.iErrorCode[FD_READ_BIT] == 0)
{
char szText[256];
int nRecv = recv(s,szText,strlen(szText),0);
if(nRecv > 0)
{
szText[nRecv] = '\0';
printf("接收到数据:%s\n",szText);
}
else
{
break;
}
}
else
break;
}
else if(event.lNetworkEvents & FD_CLOSE)
{
break;
}
else if(event.lNetworkEvents & FD_WRITE)
{
printf("FD_WRITE==========================\n");
}
return TRUE;
} while (FALSE);
printf("socket error2!\n");
RemoveSocket(pThread,s);
return FALSE;
}


DWORD WINAPI ServerThread(LPVOID lpParam)
{
PTHREAD_OBJ pThread = (PTHREAD_OBJ)lpParam;


while(TRUE)
{
int nIndex = WSAWaitForMultipleEvents(
pThread->nSocksUsed,pThread->events,FALSE,WSA_INFINITE,FALSE);
nIndex = nIndex - WSA_WAIT_EVENT_0;


if(nIndex == WSA_WAIT_FAILED || nIndex == WSA_WAIT_TIMEOUT)
{
printf("WSAWaitForMultipleEvents error!\n");
continue;
}
else if(nIndex == 0)
{
ResetEvent(pThread->events[0]);
}
else
{
HandleIo(pThread,nIndex);
}
if(!g_bServerRunning && pThread->nSocksUsed == 1)
break;
}
FreeThreadObj(pThread);
return 0;
}


BOOL AssignToFreeThread(SOCKET s)
{
if(s == INVALID_SOCKET)
return FALSE;
BOOL bAllSucceed = TRUE;
EnterCriticalSection(&g_cs);
PTHREAD_OBJ pThread = g_pThreadList;
while(pThread != NULL)
{
if(InsertSocket(pThread,s))
{
break;
}
pThread = pThread->pNext;
}
if(pThread == NULL)
{
if(g_nThreadsCount < 1000)
{
pThread = CreateThreadObj();
HANDLE hThread = CreateThread(NULL,0,ServerThread,pThread,0,NULL);
if(!hThread)
{
bAllSucceed = FALSE;
FreeThreadObj(pThread);
}
else
{
g_hThreads[g_nThreadsCount++] = hThread;
InsertSocket(pThread,s);
}
}
else
bAllSucceed = FALSE;
}
LeaveCriticalSection(&g_cs);
return bAllSucceed;
}


DWORD WINAPI ControlThread(LPVOID lpParma)
{
HANDLE wsaEvent = (HANDLE)lpParma;
char cmd[128];
while(scanf("%s",cmd))
{
if(cmd[0] == 's')
{
g_bServerRunning = FALSE;
EnterCriticalSection(&g_cs);
PTHREAD_OBJ pThread = g_pThreadList;
while(pThread != NULL)
{
EnterCriticalSection(&pThread->cs);
for(int i=0;i<pThread->nSocksUsed;i++)
{
closesocket(pThread->sockets[i]);
}
WSASetEvent(pThread->events[0]);
LeaveCriticalSection(&pThread->cs);
pThread = pThread->pNext;
}
LeaveCriticalSection(&g_cs);
WSASetEvent(wsaEvent);
break;
}
}
return 0;
}


int main()
{
WSAData wsaData;
if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))
{
printf("初始化失败!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}
USHORT nport = 3456;
SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.S_un.S_addr = ADDR_ANY;


if(SOCKET_ERROR == bind(sListen,(sockaddr*)&sin,sizeof(sin)))
{
printf("bind failed!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}


listen(sListen,200);


WSAEVENT wsaEvent = WSACreateEvent();
WSAEventSelect(sListen,wsaEvent,FD_ACCEPT | FD_CLOSE);
InitializeCriticalSectionAndSpinCount(&g_cs,4000);
g_bServerRunning = TRUE;
HANDLE hThread = CreateThread(NULL,0,ControlThread,wsaEvent,0,NULL);
CloseHandle(hThread);
while(TRUE)
{
int nRet = WaitForSingleObject(wsaEvent,5*1000);
if(!g_bServerRunning)
{
closesocket(sListen);
WSACloseEvent(wsaEvent);
WSAWaitForMultipleEvents(g_nThreadsCount,g_hThreads,TRUE,INFINITE,FALSE);
for(int i=0;i<g_nThreadsCount;i++)
{
CloseHandle(g_hThreads[i]);
}
break;
}
if(nRet == WAIT_FAILED)
{
printf("WaitForSingleObject Failed!\n");
break;
}
else if(nRet == WAIT_TIMEOUT)
{
printf("\nTotalConnections: %d\nCurrentConnections: %d\nThreads:%d\n",
g_nTotalConnections,g_nCurrentConnections,g_nThreadsCount);
continue;
}
else
{
ResetEvent(wsaEvent);
while(TRUE)
{
sockaddr_in addrRemote;
int nLen = sizeof(addrRemote);
SOCKET sNew = accept(sListen,(sockaddr*)&addrRemote,&nLen);
if(sNew == SOCKET_ERROR)
break;

if(!AssignToFreeThread(sNew))
{
closesocket(sNew);
printf("AssignToFreeThread Failed！\n");
}
}
}
}
DeleteCriticalSection(&g_cs);
return 0;
}

六，重叠I/O模型。
若需要建线程池，可参考事件选择模型。若纠结于send，可参考下面的IOCP。
[cpp] view plaincopy
#include <WinSock2.h>
#include <Windows.h>
#include <MSWSock.h>
#include <stdio.h>


#pragma comment(lib,"Ws2_32.lib")


#define BUFFER_SIZE 4096


typedef struct _SOCKET_OBJ
{
SOCKET s;
int nOutstandingOps;
LPFN_ACCEPTEX lpfnAcceptEx;
}SOCKET_OBJ,*PSOCKET_OBJ;


PSOCKET_OBJ CreateSocketObj(SOCKET s)
{
PSOCKET_OBJ pSocket = new SOCKET_OBJ();
if(pSocket != NULL)
pSocket->s = s;
return pSocket;
}


void FreeSocketObj(PSOCKET_OBJ pSocket)
{
if(pSocket == NULL)
return;
if(pSocket->s != INVALID_SOCKET)
closesocket(pSocket->s);
delete pSocket;
}


typedef struct _BUFFER_OBJ
{
OVERLAPPED ol;
char* buff;
int nLen;
PSOCKET_OBJ pSocket;
int nOperation;
#define OP_ACCEPT 1
#define OP_READ 2
#define OP_WRITE 3
SOCKET sAccept;
_BUFFER_OBJ* pNext;
}BUFFER_OBJ,*PBUFFER_OBJ;






HANDLE g_events[WSA_MAXIMUM_WAIT_EVENTS];
int g_nBufferCount;
PBUFFER_OBJ g_pBufferHeader,g_pBufferTail;
BOOL g_bServerRunning;
CRITICAL_SECTION g_cs;


PBUFFER_OBJ CreateBufferObj(PSOCKET_OBJ pSocket,ULONG nLen)
{
if(g_nBufferCount > WSA_MAXIMUM_WAIT_EVENTS - 1)
return NULL;
PBUFFER_OBJ pBuffer = new BUFFER_OBJ();
if(pBuffer != NULL)
{
pBuffer->buff = new char[nLen];
pBuffer->nLen = nLen;
pBuffer->ol.hEvent = WSACreateEvent();
pBuffer->pSocket = pSocket;
pBuffer->sAccept = INVALID_SOCKET;
pBuffer->pNext = NULL;
EnterCriticalSection(&g_cs);
if(g_pBufferHeader == NULL)
{
g_pBufferHeader = g_pBufferTail = pBuffer;
}
else
{
g_pBufferTail->pNext = pBuffer;
g_pBufferTail = pBuffer;
}
LeaveCriticalSection(&g_cs);
g_events[++g_nBufferCount] = pBuffer->ol.hEvent;
}
return pBuffer;
}


void FreeBufferObj(PBUFFER_OBJ pBuffer)
{
EnterCriticalSection(&g_cs);
PBUFFER_OBJ pTest = g_pBufferHeader;
BOOL bFind = FALSE;
if(pTest == pBuffer)
{
if(g_pBufferHeader == g_pBufferTail)
g_pBufferHeader = g_pBufferTail = NULL;
else
g_pBufferHeader = g_pBufferHeader->pNext;
bFind = TRUE;
}
else
{
while(pTest != NULL && pTest->pNext != pBuffer)
pTest = pTest->pNext;
if(pTest != NULL)
{
pTest->pNext = pBuffer->pNext;
if(pTest->pNext == NULL)
g_pBufferTail = pTest;
bFind = TRUE;
}
}

if(bFind)
{
g_nBufferCount--;
WSACloseEvent(pBuffer->ol.hEvent);
delete [] pBuffer->buff;
delete pBuffer;
}
LeaveCriticalSection(&g_cs);
}


PBUFFER_OBJ FindBufferObj(HANDLE hEvent)
{
if(hEvent == NULL || hEvent == INVALID_HANDLE_VALUE)
return NULL;
EnterCriticalSection(&g_cs);
PBUFFER_OBJ pTest = g_pBufferHeader;
while(pTest != NULL && pTest->ol.hEvent != hEvent)
pTest = pTest->pNext;
LeaveCriticalSection(&g_cs);
return pTest;
}


void RebuildArray()
{
EnterCriticalSection(&g_cs);
PBUFFER_OBJ pBuffer = g_pBufferHeader;
int i=1;
while(pBuffer != NULL)
{
g_events[i++] = pBuffer->ol.hEvent;
pBuffer = pBuffer->pNext;
}
LeaveCriticalSection(&g_cs);
}


BOOL PostAccept(PBUFFER_OBJ pBuffer)
{
PSOCKET_OBJ pSocket = pBuffer->pSocket;
if(pSocket->lpfnAcceptEx != NULL)
{
pBuffer->nOperation = OP_ACCEPT;
pSocket->nOutstandingOps++;


DWORD dwBytes;
pBuffer->sAccept = WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
BOOL b = pSocket->lpfnAcceptEx(pSocket->s,
pBuffer->sAccept,pBuffer->buff,BUFFER_SIZE - ((sizeof(sockaddr_in) + 16)*2),
sizeof(sockaddr_in) + 16, sizeof(sockaddr_in) + 16,&dwBytes,&pBuffer->ol);
if(!b)
{
if(WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}
return FALSE;
}


BOOL PostRecv(PBUFFER_OBJ pBuffer)
{
pBuffer->nOperation = OP_READ;
pBuffer->pSocket->nOutstandingOps++;


DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(WSARecv(pBuffer->pSocket->s,&buf,1,&dwBytes,&dwFlags,&pBuffer->ol,NULL))
{
if(WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}


BOOL PostSend(PBUFFER_OBJ pBuffer)
{
pBuffer->nOperation = OP_WRITE;
pBuffer->pSocket->nOutstandingOps++;
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(WSASend(pBuffer->pSocket->s,&buf,1,&dwBytes,dwFlags,&pBuffer->ol,NULL))
{
if(WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}


BOOL HandleIo(PBUFFER_OBJ pBuffer)
{
if(pBuffer == NULL)
return FALSE;


PSOCKET_OBJ pSocket = pBuffer->pSocket;
pSocket->nOutstandingOps--;


DWORD dwTrans;
DWORD dwFlags;
BOOL bRet = WSAGetOverlappedResult(pSocket->s,&pBuffer->ol,&dwTrans,FALSE,&dwFlags);
if(!bRet)
{
if(pSocket->s != INVALID_SOCKET)
{
closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}
if(pBuffer->nOperation == OP_ACCEPT && pBuffer->sAccept != INVALID_SOCKET)
{
closesocket(pBuffer->sAccept);
pBuffer->sAccept = INVALID_SOCKET;
}
if(pSocket->nOutstandingOps == 0)
{
FreeSocketObj(pSocket);
}
FreeBufferObj(pBuffer);
return FALSE;
}


switch(pBuffer->nOperation)
{
case OP_ACCEPT:
{
if(dwTrans > 0)
{
pBuffer->buff[dwTrans] = 0;
printf("Accept收到数据：%s\n",pBuffer->buff);


PSOCKET_OBJ pClient = CreateSocketObj(pBuffer->sAccept);
PBUFFER_OBJ pRecv = CreateBufferObj(pClient,BUFFER_SIZE);
if(pRecv == NULL)
{
printf("Too much connections!\n");
FreeSocketObj(pClient);
return FALSE;
}
RebuildArray();
if(!PostRecv(pRecv))
{
FreeSocketObj(pClient);
FreeBufferObj(pBuffer);
return FALSE;
}
}
else
{
if(pSocket->s != INVALID_SOCKET)
{
closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}
if(pBuffer->sAccept != INVALID_SOCKET)
{
closesocket(pBuffer->sAccept);
pBuffer->sAccept = INVALID_SOCKET;
}
if(pSocket->nOutstandingOps == 0)
{
FreeSocketObj(pSocket);
}
FreeBufferObj(pBuffer);
}
// PBUFFER_OBJ pSend = CreateBufferObj(pClient,BUFFER_SIZE);
//if(pSend == NULL)
//{
// printf("Too much connections!\n");
// FreeSocketObj(pClient);
// return FALSE;
//}
//RebuildArray();
//pSend->nLen = dwTrans;
//memcpy(pSend->buff,pBuffer->buff,dwTrans);


//if(!PostSend(pSend))
//{
// FreeSocketObj(pSocket);
// FreeBufferObj(pBuffer);
// return FALSE;
//}


PostAccept(pBuffer);
}break;
case OP_READ:
{
if(dwTrans > 0)
{
pBuffer->buff[dwTrans] = 0;
printf("Recv收到数据：%s\n",pBuffer->buff);
PostRecv(pBuffer);
}
else
{
if(pSocket->s != INVALID_SOCKET)
{
closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}
if(pSocket->nOutstandingOps == 0)
{
FreeSocketObj(pSocket);
}
FreeBufferObj(pBuffer);
}
}break;
case OP_WRITE:
{
if(dwTrans > 0)
{
pBuffer->buff[dwTrans] = 0;
printf("发送数据: %s 成功！\n",pBuffer->buff);
FreeBufferObj(pBuffer);
}
else
{
if(pSocket->s != INVALID_SOCKET)
{
closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}
if(pSocket->nOutstandingOps == 0)
{
FreeSocketObj(pSocket);
}
FreeBufferObj(pBuffer);
}
}break;
}
}


DWORD WINAPI ControlThread(LPVOID lpParma)
{
char cmd[128];
while(scanf("%s",cmd))
{
if(cmd[0] == 's')
{
g_bServerRunning = FALSE;
EnterCriticalSection(&g_cs);
PBUFFER_OBJ pBuffer = g_pBufferHeader;
while(pBuffer != NULL)
{
if(pBuffer->pSocket != NULL && pBuffer->pSocket->s != INVALID_SOCKET)
closesocket(pBuffer->pSocket->s);
pBuffer = pBuffer->pNext;
}
LeaveCriticalSection(&g_cs);
break;
}
}
return 0;
}


int main()
{
InitializeCriticalSectionAndSpinCount(&g_cs,4000);
WSAData wsaData;
if(0 != WSAStartup(MAKEWORD(2,2),&wsaData))
{
printf("初始化失败!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}
USHORT nport = 3456;
SOCKET sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.S_un.S_addr = ADDR_ANY;


if(SOCKET_ERROR == bind(sListen,(sockaddr*)&sin,sizeof(sin)))
{
printf("bind failed!%d\n",WSAGetLastError());
Sleep(5000);
return -1;
}


listen(sListen,200);




g_bServerRunning = TRUE;
PSOCKET_OBJ pListen = CreateSocketObj(sListen);
GUID GuidAcceptEx = WSAID_ACCEPTEX;
DWORD dwBytes;
WSAIoctl(pListen->s,
SIO_GET_EXTENSION_FUNCTION_POINTER,
&GuidAcceptEx,
sizeof(GuidAcceptEx),
&pListen->lpfnAcceptEx,
sizeof(pListen->lpfnAcceptEx),
&dwBytes,
NULL,
NULL);
g_events[0] = WSACreateEvent();


for(int i=0;i<5;++i)
{
PostAccept(CreateBufferObj(pListen,BUFFER_SIZE));
}

HANDLE hThread = CreateThread(NULL,0,ControlThread,NULL,0,NULL);
while(TRUE)
{
int nIndex = WSAWaitForMultipleEvents(g_nBufferCount+1,g_events,FALSE,WSA_INFINITE,FALSE);
if(nIndex == WSA_WAIT_FAILED)
{
printf("WSAWaitForMultipleEvents Failed!\n");
break;
}
nIndex = nIndex - WSA_WAIT_EVENT_0;
for(int i=nIndex;i<= g_nBufferCount;i++)
{
int nRet = WSAWaitForMultipleEvents(1,&g_events[i],FALSE,0,FALSE);
if(nRet == WSA_WAIT_TIMEOUT)
continue;


if(i == 0)
{
RebuildArray();
continue;
}


PBUFFER_OBJ pBuffer = FindBufferObj(g_events[i]);
if(pBuffer != NULL)
{
if(!HandleIo(pBuffer))
RebuildArray();
}
}
if(!g_bServerRunning && g_nBufferCount == 0)
break;
}
WSACloseEvent(g_events[0]);
WaitForSingleObject(hThread,INFINITE);
CloseHandle(hThread);
closesocket(sListen);
WSACleanup();
DeleteCriticalSection(&g_cs);
return 0;
}

七，IOCP。
大框架为书中例子，对强化了发送操作，部分异常处理，且加入了连接超时处理。
注意：当一个投递完成，且对应socket上已经没有未决的投递，必须要再投递一个请求或者关闭连接，否则socket对应的数据结构无法被释放，对应socket连接断开时也无法被
检测到。所以如果业务逻辑结束，要关闭连接。或者你需要等客户端来断开连接，那么你可以在业务逻辑结束后，再投递一个接收请求（客户端断开时，接收请求返回且接收的字节数为0，则此类中的异常处理逻辑便会将资源清理掉）。
头文件
[cpp] view plaincopy
////////////////////////////////////////
// IOCP.h文件


#ifndef __IOCP_H__
#define __IOCP_H__


#include <winsock2.h>
#include <windows.h>
#include <Mswsock.h>


#define BUFFER_SIZE 1024*4 // I/O请求的缓冲区大小
#define MAX_THREAD 1 // I/O服务线程的数量




// 这是per-I/O数据。它包含了在套节字上处理I/O操作的必要信息
struct CIOCPBuffer
{
CIOCPBuffer()
{
memset(&ol,0,sizeof(WSAOVERLAPPED));
sClient = INVALID_SOCKET;
memset(buff,0,BUFFER_SIZE);
nLen = 0;
nSequenceNumber = 0;
bIsReleased = FALSE;
nOperation = 0;
pNext = NULL;
}
WSAOVERLAPPED ol;


SOCKET sClient; // AcceptEx接收的客户方套节字


char buff[BUFFER_SIZE]; // I/O操作使用的缓冲区
int nLen; // buff缓冲区（使用的）大小


ULONG nSequenceNumber; // 此I/O的序列号
BOOL bIsReleased;


int nOperation; // 操作类型
#define OP_ACCEPT 1
#define OP_WRITE 2
#define OP_READ 3


CIOCPBuffer *pNext;
};
struct CIOCPNextToSend;
struct CIOCPTimerData;
// 这是per-Handle数据。它包含了一个套节字的信息
struct CIOCPContext
{
CIOCPContext()
{
s = INVALID_SOCKET;
memset(&addrLocal,0,sizeof(SOCKADDR_IN));
memset(&addrRemote,0,sizeof(SOCKADDR_IN));
bClosing = FALSE;
nOutstandingRecv = 0;
nOutstandingSend = 0;
nReadSequence = 0;
nCurrentReadSequence = 0;
nCurrentStep = 0;
pOutOfOrderReads = NULL;
pNextToSend = NULL;
bIsReleased = FALSE;
pNext = NULL;
pPreData = NULL;
strcpy(szClientName,"");
hTimer = NULL;
hCompletion = NULL;
}
CIOCPBuffer m_pBuffer;
SOCKET s; // 套节字句柄


SOCKADDR_IN addrLocal; // 连接的本地地址
SOCKADDR_IN addrRemote; // 连接的远程地址


BOOL bClosing; // 套节字是否关闭


int nOutstandingRecv; // 此套节字上抛出的重叠操作的数量
int nOutstandingSend;




ULONG nReadSequence; // 安排给接收的下一个序列号
ULONG nCurrentReadSequence; // 当前要读的序列号

CIOCPBuffer *pOutOfOrderReads; // 记录没有按顺序完成的读I/O
CIOCPNextToSend *pNextToSend; //xss,按顺序发送的下一个要发送的。


LPVOID pPreData; //xss，用于2个过程之间的数据交流。
ULONG nCurrentStep;//xss,用于记录当前处于的过程步骤数。
BOOL bIsReleased;


CRITICAL_SECTION Lock; // 保护这个结构


CIOCPContext *pNext;


char szClientName[256];//xss
HANDLE hTimer;//xss
HANDLE hCompletion;//xss


};


struct CIOCPNextToSend//xss
{
CIOCPBuffer * pBuffer;
CIOCPNextToSend * pNext;
};


struct CIOCPTimerData
{
CIOCPContext* pContext;
HANDLE hCompletion;
};


class CIOCPServer // 处理线程
{
public:
CIOCPServer();
~CIOCPServer();


// 开始服务
BOOL Start(int nPort = 3456, int nMaxConnections = 2000,
int nMaxFreeBuffers = 200, int nMaxFreeContexts = 100, int nInitialReads = 4);
// 停止服务
void Shutdown();


// 关闭一个连接和关闭所有连接
void CloseAConnection(CIOCPContext *pContext);
void CloseAllConnections();


// 取得当前的连接数量
ULONG GetCurrentConnection() { return m_nCurrentConnection; }


// 向指定客户发送文本
BOOL SendText(CIOCPContext *pContext, char *pszText, int nLen);


protected:


// 申请和释放缓冲区对象
CIOCPBuffer *AllocateBuffer(int nLen);
void ReleaseBuffer(CIOCPBuffer *pBuffer);


// 申请和释放套节字上下文
CIOCPContext *AllocateContext(SOCKET s);
void ReleaseContext(CIOCPContext *pContext);


// 释放空闲缓冲区对象列表和空闲上下文对象列表
void FreeBuffers();
void FreeContexts();


// 向连接列表中添加一个连接
BOOL AddAConnection(CIOCPContext *pContext);


// 插入和移除未决的接受请求
BOOL InsertPendingAccept(CIOCPBuffer *pBuffer);
BOOL RemovePendingAccept(CIOCPBuffer *pBuffer);


//xss,把要发送的数据加入队列，按顺序发送
BOOL PostSendToList(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
//xss,发送下一个需要发送的
BOOL PostNextWriteBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
// 取得下一个要读取的
CIOCPBuffer *GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer);




void ErrorHandle(CIOCPContext *pContext, CIOCPBuffer *pBuffer);//xss,错误集中处理
// 投递接受I/O、发送I/O、接收I/O
BOOL PostAccept(CIOCPBuffer *pBuffer);
BOOL PostSend(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
BOOL PostRecv(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
BOOL PostRecv2(CIOCPContext *pContext, CIOCPBuffer *pBuffer);


void HandleIO(DWORD dwKey, CIOCPBuffer *pBuffer, DWORD dwTrans, int nError);




// 事件通知函数
// 建立了一个新的连接
virtual void OnConnectionEstablished(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
// 一个连接关闭
virtual void OnConnectionClosing(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
// 在一个连接上发生了错误
virtual void OnConnectionError(CIOCPContext *pContext, CIOCPBuffer *pBuffer, int nError);
// 一个连接上的读操作完成
virtual void OnReadCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
// 一个连接上的写操作完成
virtual void OnWriteCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer);


protected:


// 记录空闲结构信息
CIOCPBuffer *m_pFreeBufferList;
CIOCPContext *m_pFreeContextList;
int m_nFreeBufferCount;
int m_nFreeContextCount;
CRITICAL_SECTION m_FreeBufferListLock;
CRITICAL_SECTION m_FreeContextListLock;


CRITICAL_SECTION m_HeapLock;
CRITICAL_SECTION m_RepostLock;


// 记录抛出的Accept请求
CIOCPBuffer *m_pPendingAccepts; // 抛出请求列表。
long m_nPendingAcceptCount;
CRITICAL_SECTION m_PendingAcceptsLock;


// 记录连接列表
CIOCPContext *m_pConnectionList;
int m_nCurrentConnection;
CRITICAL_SECTION m_ConnectionListLock;


// 用于投递Accept请求
HANDLE m_hAcceptEvent;
HANDLE m_hRepostEvent;
LONG m_nRepostCount;


int m_nPort; // 服务器监听的端口


int m_nInitialAccepts;
int m_nInitialReads;
int m_nMaxAccepts;
int m_nMaxSends;
int m_nMaxFreeBuffers;
int m_nMaxFreeContexts;
int m_nMaxConnections;


HANDLE m_hListenThread; // 监听线程
HANDLE m_hCompletion; // 完成端口句柄
SOCKET m_sListen; // 监听套节字句柄
LPFN_ACCEPTEX m_lpfnAcceptEx; // AcceptEx函数地址
LPFN_GETACCEPTEXSOCKADDRS m_lpfnGetAcceptExSockaddrs; // GetAcceptExSockaddrs函数地址


BOOL m_bShutDown; // 用于通知监听线程退出
BOOL m_bServerStarted; // 记录服务是否启动


HANDLE m_hTimerQueue;//xss


private: // 线程函数
static DWORD WINAPI _ListenThreadProc(LPVOID lpParam);
static DWORD WINAPI _WorkerThreadProc(LPVOID lpParam);
};




#endif // __IOCP_H__

cpp文件
[cpp] view plaincopy
//////////////////////////////////////////////////
// IOCP.cpp文件
#define _WIN32_WINNT 0x0500 //xss


#include "iocp.h"
#pragma comment(lib, "WS2_32.lib")


#include <stdio.h>
#include "httpFun.h"


static int iBufferCount = 0;
static int iContextCount = 0;
CIOCPServer::CIOCPServer()
{
// 列表
m_pFreeBufferList = NULL;
m_pFreeContextList = NULL;
m_pPendingAccepts = NULL;
m_pConnectionList = NULL;


m_nFreeBufferCount = 0;
m_nFreeContextCount = 0;
m_nPendingAcceptCount = 0;
m_nCurrentConnection = 0;


::InitializeCriticalSection(&m_FreeBufferListLock);
::InitializeCriticalSection(&m_FreeContextListLock);
::InitializeCriticalSection(&m_PendingAcceptsLock);
::InitializeCriticalSection(&m_ConnectionListLock);


::InitializeCriticalSection(&m_HeapLock);
::InitializeCriticalSection(&m_RepostLock);


// Accept请求
m_hAcceptEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
m_hRepostEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
m_nRepostCount = 0;


m_nPort = 8888;


m_nInitialAccepts = 10;
m_nInitialReads = 4;
m_nMaxAccepts = 100;
m_nMaxSends = 20;
m_nMaxFreeBuffers = 200;
m_nMaxFreeContexts = 100;
m_nMaxConnections = 2000;


m_hListenThread = NULL;
m_hCompletion = NULL;
m_sListen = INVALID_SOCKET;
m_lpfnAcceptEx = NULL;
m_lpfnGetAcceptExSockaddrs = NULL;


m_bShutDown = FALSE;
m_bServerStarted = FALSE;


m_hTimerQueue = ::CreateTimerQueue();


// 初始化WS2_32.dll
WSADATA wsaData;
WORD sockVersion = MAKEWORD(2, 2);
::WSAStartup(sockVersion, &wsaData);
}


CIOCPServer::~CIOCPServer()
{
Shutdown();


if(m_sListen != INVALID_SOCKET)
::closesocket(m_sListen);
if(m_hListenThread != NULL)
::CloseHandle(m_hListenThread);


::CloseHandle(m_hRepostEvent);
::CloseHandle(m_hAcceptEvent);


::DeleteCriticalSection(&m_FreeBufferListLock);
::DeleteCriticalSection(&m_FreeContextListLock);
::DeleteCriticalSection(&m_PendingAcceptsLock);
::DeleteCriticalSection(&m_ConnectionListLock);


::DeleteCriticalSection(&m_HeapLock);
::DeleteCriticalSection(&m_RepostLock);


::DeleteTimerQueue(m_hTimerQueue);//xss
::WSACleanup();
}


///////////////////////////////////////
static VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired)
{
CIOCPContext* pContext = (CIOCPContext*)lpParam;
if(pContext != NULL && pContext->bClosing == FALSE)
{
EnterCriticalSection(&pContext->Lock);
if(pContext->hCompletion != NULL)
{
PostQueuedCompletionStatus(pContext->hCompletion,-2,(ULONG_PTR)pContext,NULL);
}
LeaveCriticalSection(&pContext->Lock);
}
}






///////////////////////////////////
// 自定义帮助函数


CIOCPBuffer *CIOCPServer::AllocateBuffer(int nLen)
{
CIOCPBuffer *pBuffer = NULL;
if(nLen > BUFFER_SIZE)
return NULL;


// 为缓冲区对象申请内存
::EnterCriticalSection(&m_FreeBufferListLock);
if(m_pFreeBufferList == NULL) // 内存池为空，申请新的内存
{
// pBuffer = (CIOCPBuffer *)::HeapAlloc(GetProcessHeap(),
// HEAP_ZERO_MEMORY, sizeof(CIOCPBuffer) + BUFFER_SIZE);
pBuffer = new CIOCPBuffer();
}
else // 从内存池中取一块来使用
{
pBuffer = m_pFreeBufferList;
m_pFreeBufferList = m_pFreeBufferList->pNext;
pBuffer->pNext = NULL;
m_nFreeBufferCount --;
}
::LeaveCriticalSection(&m_FreeBufferListLock);


EnterCriticalSection(&m_HeapLock);
iBufferCount++;
LeaveCriticalSection(&m_HeapLock);


// 初始化新的缓冲区对象
if(pBuffer != NULL)
{
//pBuffer->buff = (char*)(pBuffer + sizeof(CIOCPBuffer)/*1*/);//xss,个人以为应该+sizeof(CIOCPBuffer);
pBuffer->nLen = nLen;
pBuffer->bIsReleased = FALSE;
}
return pBuffer;
}


void CIOCPServer::ReleaseBuffer(CIOCPBuffer *pBuffer)
{
if(pBuffer == NULL || pBuffer->bIsReleased)
return;


::EnterCriticalSection(&m_FreeBufferListLock);


if(m_nFreeBufferCount <= m_nMaxFreeBuffers) // 将要释放的内存添加到空闲列表中
{
memset(pBuffer, 0, sizeof(CIOCPBuffer) /*+ BUFFER_SIZE*/);
pBuffer->pNext = m_pFreeBufferList;
m_pFreeBufferList = pBuffer;


m_nFreeBufferCount ++ ;


pBuffer->bIsReleased = TRUE;
}
else // 已经达到最大值，真正的释放内存
{
//::HeapFree(::GetProcessHeap(), 0, pBuffer);
delete pBuffer;
}


::LeaveCriticalSection(&m_FreeBufferListLock);


EnterCriticalSection(&m_HeapLock);
iBufferCount--;
LeaveCriticalSection(&m_HeapLock);
}




CIOCPContext *CIOCPServer::AllocateContext(SOCKET s)
{
CIOCPContext *pContext;


// 申请一个CIOCPContext对象
::EnterCriticalSection(&m_FreeContextListLock);


if(m_pFreeContextList == NULL)
{
//pContext = (CIOCPContext *)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CIOCPContext));
pContext = new CIOCPContext();


::InitializeCriticalSection(&pContext->Lock);
}
else
{
// 在空闲列表中申请
pContext = m_pFreeContextList;
m_pFreeContextList = m_pFreeContextList->pNext;
pContext->pNext = NULL;
m_nFreeBufferCount --;
}
::LeaveCriticalSection(&m_FreeContextListLock);


EnterCriticalSection(&m_HeapLock);
iContextCount++;
LeaveCriticalSection(&m_HeapLock);


// 初始化对象成员
if(pContext != NULL)
{
pContext->s = s;
pContext->bIsReleased = FALSE;
}
return pContext;
}


void CIOCPServer::ReleaseContext(CIOCPContext *pContext)
{
if(pContext == NULL || pContext->bIsReleased)
return;


printf("\n%s释放了Context\n\n",pContext->szClientName);
if(pContext->s != INVALID_SOCKET)
::closesocket(pContext->s);


// 首先释放（如果有的话）此套节字上的没有按顺序完成的读I/O的缓冲区
CIOCPBuffer *pNext;
while(pContext->pOutOfOrderReads != NULL)
{
pNext = pContext->pOutOfOrderReads->pNext;
ReleaseBuffer(pContext->pOutOfOrderReads);
pContext->pOutOfOrderReads = pNext;
}


//xss,再释放（如果有的话）此套接字上未完成的写I/O缓冲区
CIOCPNextToSend* pSend = NULL;
while(pContext->pNextToSend != NULL)
{
pSend = pContext->pNextToSend->pNext;
if(pContext->pNextToSend->pBuffer != NULL && pContext->pNextToSend->pBuffer->bIsReleased == FALSE)
{
ReleaseBuffer(pContext->pNextToSend->pBuffer);
}
delete pContext->pNextToSend;
pContext->pNextToSend = pSend;
}


if(pContext->hTimer != NULL)
{
DeleteTimerQueueTimer(m_hTimerQueue,pContext->hTimer,NULL);
pContext->hTimer = NULL;
}


::EnterCriticalSection(&m_FreeContextListLock);

if(m_nFreeContextCount <= m_nMaxFreeContexts) // 添加到空闲列表
{
// 先将关键代码段变量保存到一个临时变量中
CRITICAL_SECTION cstmp = pContext->Lock;
// 将要释放的上下文对象初始化为0
memset(pContext, 0, sizeof(CIOCPContext));


// 再放会关键代码段变量，将要释放的上下文对象添加到空闲列表的表头
pContext->Lock = cstmp;
pContext->pNext = m_pFreeContextList;
m_pFreeContextList = pContext;

// 更新计数
m_nFreeContextCount ++;


pContext->bIsReleased = TRUE;
}
else
{
::DeleteCriticalSection(&pContext->Lock);
//::HeapFree(::GetProcessHeap(), 0, pContext);
delete pContext;
}
::LeaveCriticalSection(&m_FreeContextListLock);



EnterCriticalSection(&m_HeapLock);
iContextCount--;
LeaveCriticalSection(&m_HeapLock);
}


void CIOCPServer::FreeBuffers()
{
// 遍历m_pFreeBufferList空闲列表，释放缓冲区池内存
::EnterCriticalSection(&m_FreeBufferListLock);


CIOCPBuffer *pFreeBuffer = m_pFreeBufferList;
CIOCPBuffer *pNextBuffer;
while(pFreeBuffer != NULL)
{
pNextBuffer = pFreeBuffer->pNext;


delete pFreeBuffer;
// if(!::HeapFree(::GetProcessHeap(), 0, pFreeBuffer))
// {
// #ifdef _DEBUG
// ::OutputDebugString(" FreeBuffers释放内存出错！");
// #endif // _DEBUG
// break;
// }
pFreeBuffer = pNextBuffer;
}
m_pFreeBufferList = NULL;
m_nFreeBufferCount = 0;


::LeaveCriticalSection(&m_FreeBufferListLock);
}


void CIOCPServer::FreeContexts()
{
// 遍历m_pFreeContextList空闲列表，释放缓冲区池内存
::EnterCriticalSection(&m_FreeContextListLock);

CIOCPContext *pFreeContext = m_pFreeContextList;
CIOCPContext *pNextContext;
while(pFreeContext != NULL)
{
pNextContext = pFreeContext->pNext;

::DeleteCriticalSection(&pFreeContext->Lock);
delete pFreeContext;
// if(!::HeapFree(::GetProcessHeap(), 0, pFreeContext))
// {
// #ifdef _DEBUG
// ::OutputDebugString(" FreeBuffers释放内存出错！");
// #endif // _DEBUG
// break;
// }
pFreeContext = pNextContext;
}
m_pFreeContextList = NULL;
m_nFreeContextCount = 0;


::LeaveCriticalSection(&m_FreeContextListLock);
}




BOOL CIOCPServer::AddAConnection(CIOCPContext *pContext)
{
// 向客户连接列表添加一个CIOCPContext对象


::EnterCriticalSection(&m_ConnectionListLock);
if(m_nCurrentConnection <= m_nMaxConnections)
{
// 添加到表头
pContext->pNext = m_pConnectionList;
m_pConnectionList = pContext;
// 更新计数
m_nCurrentConnection ++;


::LeaveCriticalSection(&m_ConnectionListLock);
return TRUE;
}
::LeaveCriticalSection(&m_ConnectionListLock);


return FALSE;
}


void CIOCPServer::CloseAConnection(CIOCPContext *pContext)
{
if(pContext == NULL || pContext->bClosing == TRUE)
return;


// 首先从列表中移除要关闭的连接
::EnterCriticalSection(&m_ConnectionListLock);


CIOCPContext* pTest = m_pConnectionList;
if(pTest == pContext)
{
m_pConnectionList = pContext->pNext;
m_nCurrentConnection --;
}
else
{
while(pTest != NULL && pTest->pNext != pContext)
pTest = pTest->pNext;
if(pTest != NULL)
{
pTest->pNext = pContext->pNext;
m_nCurrentConnection --;
}
}

::LeaveCriticalSection(&m_ConnectionListLock);


// 然后关闭客户套节字
::EnterCriticalSection(&pContext->Lock);


if(pContext->s != INVALID_SOCKET)
{
::closesocket(pContext->s);
pContext->s = INVALID_SOCKET;
}
pContext->bClosing = TRUE;


::LeaveCriticalSection(&pContext->Lock);
}


void CIOCPServer::CloseAllConnections()
{
// 遍历整个连接列表，关闭所有的客户套节字


::EnterCriticalSection(&m_ConnectionListLock);


CIOCPContext *pContext = m_pConnectionList;
while(pContext != NULL)
{
::EnterCriticalSection(&pContext->Lock);


if(pContext->s != INVALID_SOCKET)
{
::closesocket(pContext->s);
pContext->s = INVALID_SOCKET;
}


pContext->bClosing = TRUE;


::LeaveCriticalSection(&pContext->Lock);

pContext = pContext->pNext;
}


m_pConnectionList = NULL;
m_nCurrentConnection = 0;


::LeaveCriticalSection(&m_ConnectionListLock);
}




BOOL CIOCPServer::InsertPendingAccept(CIOCPBuffer *pBuffer)
{
// 将一个I/O缓冲区对象插入到m_pPendingAccepts表中


::EnterCriticalSection(&m_PendingAcceptsLock);


if(m_pPendingAccepts == NULL)
m_pPendingAccepts = pBuffer;
else
{
pBuffer->pNext = m_pPendingAccepts;
m_pPendingAccepts = pBuffer;
}
m_nPendingAcceptCount ++;


::LeaveCriticalSection(&m_PendingAcceptsLock);


return TRUE;
}


BOOL CIOCPServer::RemovePendingAccept(CIOCPBuffer *pBuffer)
{
BOOL bResult = FALSE;


// 遍历m_pPendingAccepts表，从中移除pBuffer所指向的缓冲区对象
::EnterCriticalSection(&m_PendingAcceptsLock);


CIOCPBuffer *pTest = m_pPendingAccepts;
if(pTest == pBuffer) // 如果是表头元素
{
m_pPendingAccepts = pBuffer->pNext;
bResult = TRUE;
}
else // 不是表头元素的话，就要遍历这个表来查找了
{
while(pTest != NULL && pTest->pNext != pBuffer)
pTest = pTest->pNext;
if(pTest != NULL)
{
pTest->pNext = pBuffer->pNext;
bResult = TRUE;
}
}
// 更新计数
if(bResult)
m_nPendingAcceptCount --;


::LeaveCriticalSection(&m_PendingAcceptsLock);


return bResult;
}


void CIOCPServer::ErrorHandle(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
CloseAConnection(pContext);
}


BOOL CIOCPServer::PostSendToList(CIOCPContext *pContext, CIOCPBuffer *pBuffer)//xss
{
::EnterCriticalSection(&pContext->Lock);
CIOCPNextToSend *ptr = pContext->pNextToSend;


CIOCPNextToSend * pSend = new CIOCPNextToSend();
pSend->pBuffer = pBuffer;
pSend->pNext = NULL;
if(ptr == NULL)
{
printf("数据：%10.10s ...，被直接发送。\n",pBuffer->buff);
//::EnterCriticalSection(&pContext->Lock);
pContext->pNextToSend = pSend;
//::LeaveCriticalSection(&pContext->Lock);
if(!PostSend(pContext,pBuffer))//如果没有需要等待的send就直接发送
{
::LeaveCriticalSection(&pContext->Lock);
return FALSE;
}
}
else
{
printf("数据：%10.10s ...，被放入链表结尾。\n",pBuffer->buff);
while(ptr->pNext != NULL)
{
ptr = ptr->pNext;
}
ptr->pNext = pSend;//新的发送请求放在链表结尾
}
::LeaveCriticalSection(&pContext->Lock);
return TRUE;
}


BOOL CIOCPServer::PostNextWriteBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer)//xss
{
::EnterCriticalSection(&pContext->Lock);
CIOCPNextToSend* pSend = pContext->pNextToSend;
CIOCPNextToSend* pNextSend = NULL;
if(pSend != NULL && pSend->pNext != NULL)//发送成功的pBuffer是队列的第一个，发送下一个，pNextToSend指向下一个，pBuffer由外面释放。
{
pNextSend = pSend->pNext;
if(pNextSend->pBuffer != NULL)
{
printf("数据：%10.10s ...从链表中弹出被发送。\n",pNextSend->pBuffer->buff);
if(!PostSend(pContext,pNextSend->pBuffer))
{
delete pSend;
pContext->pNextToSend = pNextSend;
::LeaveCriticalSection(&pContext->Lock);
return FALSE;
}
}
}
if(pSend != NULL)
{
pNextSend = pSend->pNext;
delete pSend;
pContext->pNextToSend = pNextSend;
}
::LeaveCriticalSection(&pContext->Lock);
return TRUE;
}


CIOCPBuffer *CIOCPServer::GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
if(pBuffer != NULL)
{
// 如果与要读的下一个序列号相等，则读这块缓冲区
if(pBuffer->nSequenceNumber == pContext->nCurrentReadSequence)
{
return pBuffer;
}

// 如果不相等，则说明没有按顺序接收数据，将这块缓冲区保存到连接的pOutOfOrderReads列表中


// 列表中的缓冲区是按照其序列号从小到大的顺序排列的


pBuffer->pNext = NULL;

CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
CIOCPBuffer *pPre = NULL;
while(ptr != NULL)
{
if(pBuffer->nSequenceNumber < ptr->nSequenceNumber)
break;

pPre = ptr;
ptr = ptr->pNext;
}

if(pPre == NULL) // 应该插入到表头
{
pBuffer->pNext = pContext->pOutOfOrderReads;
pContext->pOutOfOrderReads = pBuffer;
}
else // 应该插入到表的中间
{
pBuffer->pNext = pPre->pNext;
pPre->pNext = pBuffer/*->pNext*/;//xss,个人觉得应该是pPre->pNext = pBuffer;
}
}


// 检查表头元素的序列号，如果与要读的序列号一致，就将它从表中移除，返回给用户
CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
if(ptr != NULL && (ptr->nSequenceNumber == pContext->nCurrentReadSequence))
{
pContext->pOutOfOrderReads = ptr->pNext;
return ptr;
}
return NULL;
}




BOOL CIOCPServer::PostAccept(CIOCPBuffer *pBuffer) // 在监听套节字上投递Accept请求
{
// 设置I/O类型
pBuffer->nOperation = OP_ACCEPT;


// 投递此重叠I/O
DWORD dwBytes;
pBuffer->sClient = ::WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
BOOL b = m_lpfnAcceptEx(m_sListen,
pBuffer->sClient,
pBuffer->buff,
pBuffer->nLen - ((sizeof(sockaddr_in) + 16) * 2),//xss,第一次都是收一个cmd_header
sizeof(sockaddr_in) + 16,
sizeof(sockaddr_in) + 16,
&dwBytes,
&pBuffer->ol);
if(!b && ::WSAGetLastError() != WSA_IO_PENDING)
{
return FALSE;
}
if(pBuffer->nOperation == 0)
{
int x = 0;
}
return TRUE;
};


BOOL CIOCPServer::PostRecv(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
// 设置I/O类型
pBuffer->nOperation = OP_READ;

::EnterCriticalSection(&pContext->Lock);


// 设置序列号
pBuffer->nSequenceNumber = pContext->nReadSequence;


// 投递此重叠I/O
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(::WSARecv(pContext->s, &buf, 1, &dwBytes, &dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
{
printf("WSARecv出错：%d\n",WSAGetLastError());
::LeaveCriticalSection(&pContext->Lock);
return FALSE;
}
}


// 增加套节字上的重叠I/O计数和读序列号计数


pContext->nOutstandingRecv ++;
pContext->nReadSequence ++;


::LeaveCriticalSection(&pContext->Lock);

return TRUE;
}


BOOL CIOCPServer::PostSend(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
// 跟踪投递的发送的数量，防止用户仅发送数据而不接收，导致服务器抛出大量发送操作
if(pContext->nOutstandingSend > m_nMaxSends)
return FALSE;


// 设置I/O类型，增加套节字上的重叠I/O计数
pBuffer->nOperation = OP_WRITE;


// 投递此重叠I/O
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(::WSASend(pContext->s,
&buf, 1, &dwBytes, dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
{
int x;
if((x=::WSAGetLastError()) != WSA_IO_PENDING)
{
printf("发送失败！错误码：%d",x);
return FALSE;
}
}
// 增加套节字上的重叠I/O计数


::EnterCriticalSection(&pContext->Lock);
pContext->nOutstandingSend ++;
::LeaveCriticalSection(&pContext->Lock);


if(pBuffer->nOperation == 0)
{
int x = 0;
}
return TRUE;
}




BOOL CIOCPServer::Start(int nPort, int nMaxConnections,
int nMaxFreeBuffers, int nMaxFreeContexts, int nInitialReads)
{
// 检查服务是否已经启动
if(m_bServerStarted)
return FALSE;


// 保存用户参数
m_nPort = nPort;
m_nMaxConnections = nMaxConnections;
m_nMaxFreeBuffers = nMaxFreeBuffers;
m_nMaxFreeContexts = nMaxFreeContexts;
m_nInitialReads = nInitialReads;


// 初始化状态变量
m_bShutDown = FALSE;
m_bServerStarted = TRUE;




// 创建监听套节字，绑定到本地端口，进入监听模式
m_sListen = ::WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
SOCKADDR_IN si;
si.sin_family = AF_INET;
si.sin_port = ::ntohs(m_nPort);
si.sin_addr.S_un.S_addr = INADDR_ANY;
if(::bind(m_sListen, (sockaddr*)&si, sizeof(si)) == SOCKET_ERROR)
{
m_bServerStarted = FALSE;
return FALSE;
}
::listen(m_sListen, 200);


// 创建完成端口对象
m_hCompletion = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);


// 加载扩展函数AcceptEx
GUID GuidAcceptEx = WSAID_ACCEPTEX;
DWORD dwBytes;
::WSAIoctl(m_sListen,
SIO_GET_EXTENSION_FUNCTION_POINTER,
&GuidAcceptEx,
sizeof(GuidAcceptEx),
&m_lpfnAcceptEx,
sizeof(m_lpfnAcceptEx),
&dwBytes,
NULL,
NULL);

// 加载扩展函数GetAcceptExSockaddrs
GUID GuidGetAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
::WSAIoctl(m_sListen,
SIO_GET_EXTENSION_FUNCTION_POINTER,
&GuidGetAcceptExSockaddrs,
sizeof(GuidGetAcceptExSockaddrs),
&m_lpfnGetAcceptExSockaddrs,
sizeof(m_lpfnGetAcceptExSockaddrs),
&dwBytes,
NULL,
NULL
);


// 将监听套节字关联到完成端口，注意，这里为它传递的CompletionKey为0
::CreateIoCompletionPort((HANDLE)m_sListen, m_hCompletion, (DWORD)0, 0);


// 注册FD_ACCEPT事件。
// 如果投递的AcceptEx I/O不够，线程会接收到FD_ACCEPT网络事件，说明应该投递更多的AcceptEx I/O
WSAEventSelect(m_sListen, m_hAcceptEvent, FD_ACCEPT);


// 创建监听线程
m_hListenThread = ::CreateThread(NULL, 0, _ListenThreadProc, this, 0, NULL);

return TRUE;
}


void CIOCPServer::Shutdown()
{
if(!m_bServerStarted)
return;


// 通知监听线程，马上停止服务
m_bShutDown = TRUE;
::SetEvent(m_hAcceptEvent);
// 等待监听线程退出
::WaitForSingleObject(m_hListenThread, INFINITE);
::CloseHandle(m_hListenThread);
m_hListenThread = NULL;


m_bServerStarted = FALSE;
}


DWORD WINAPI CIOCPServer::_ListenThreadProc(LPVOID lpParam)
{
CIOCPServer *pThis = (CIOCPServer*)lpParam;


// 先在监听套节字上投递几个Accept I/O
CIOCPBuffer *pBuffer;
for(int i=0; i<pThis->m_nInitialAccepts; i++)
{
pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);//xss,BUFFER_SIZE
if(pBuffer == NULL)
return -1;
pThis->InsertPendingAccept(pBuffer);
pThis->PostAccept(pBuffer);
}


// 构建事件对象数组，以便在上面调用WSAWaitForMultipleEvents函数
HANDLE hWaitEvents[2 + MAX_THREAD];
int nEventCount = 0;
hWaitEvents[nEventCount ++] = pThis->m_hAcceptEvent;
hWaitEvents[nEventCount ++] = pThis->m_hRepostEvent;


// 创建指定数量的工作线程在完成端口上处理I/O
for(int i=0; i<MAX_THREAD; i++)
{
hWaitEvents[nEventCount ++] = ::CreateThread(NULL, 0, _WorkerThreadProc, pThis, 0, NULL);
}


// 下面进入无限循环，处理事件对象数组中的事件
while(TRUE)
{
int nIndex = ::WSAWaitForMultipleEvents(nEventCount, hWaitEvents, FALSE, 60*1000, FALSE);

// 首先检查是否要停止服务
if(pThis->m_bShutDown || nIndex == WSA_WAIT_FAILED)
{
// 关闭所有连接
pThis->CloseAllConnections();
::Sleep(0); // 给I/O工作线程一个执行的机会
// 关闭监听套节字
::closesocket(pThis->m_sListen);
pThis->m_sListen = INVALID_SOCKET;
::Sleep(0); // 给I/O工作线程一个执行的机会


// 通知所有I/O处理线程退出
for(int i=2; i<MAX_THREAD + 2; i++)
{
::PostQueuedCompletionStatus(pThis->m_hCompletion, -1, 0, NULL);
}


// 等待I/O处理线程退出
::WaitForMultipleObjects(MAX_THREAD, &hWaitEvents[2], TRUE, 5*1000);


for(int i=2; i<MAX_THREAD + 2; i++)
{
::CloseHandle(hWaitEvents[i]);
}

::CloseHandle(pThis->m_hCompletion);


pThis->FreeBuffers();
pThis->FreeContexts();
::ExitThread(0);
}


// 1）定时检查所有未返回的AcceptEx I/O的连接建立了多长时间
if(nIndex == WSA_WAIT_TIMEOUT)
{
pBuffer = pThis->m_pPendingAccepts;
while(pBuffer != NULL)
{
int nSeconds;
int nLen = sizeof(nSeconds);
// 取得连接建立的时间
::getsockopt(pBuffer->sClient,
SOL_SOCKET, SO_CONNECT_TIME, (char *)&nSeconds, &nLen);
// 如果超过2分钟客户还不发送初始数据，就让这个客户go away
if(nSeconds != -1 && nSeconds > /*2*60*/50)
{
closesocket(pBuffer->sClient);
pBuffer->sClient = INVALID_SOCKET;
}


pBuffer = pBuffer->pNext;
}
}
else
{
nIndex = nIndex - WAIT_OBJECT_0;
WSANETWORKEVENTS ne;
int nLimit=0;
if(nIndex == 0) // 2）m_hAcceptEvent事件对象受信，说明投递的Accept请求不够，需要增加
{
::WSAEnumNetworkEvents(pThis->m_sListen, hWaitEvents[nIndex], &ne);
if(ne.lNetworkEvents & FD_ACCEPT)
{
nLimit = 50; // 增加的个数，这里设为50个
}
}
else if(nIndex == 1) // 3）m_hRepostEvent事件对象受信，说明处理I/O的线程接受到新的客户
{
nLimit = InterlockedExchange(&pThis->m_nRepostCount, 0);
}
else if(nIndex > 1) // I/O服务线程退出，说明有错误发生，关闭服务器
{
pThis->m_bShutDown = TRUE;
continue;
}


// 投递nLimit个AcceptEx I/O请求
int i = 0;
while(i++ < nLimit && pThis->m_nPendingAcceptCount < pThis->m_nMaxAccepts)
{
pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);
if(pBuffer != NULL)
{
pThis->InsertPendingAccept(pBuffer);
pThis->PostAccept(pBuffer);
}
}
}
}
return 0;
}


DWORD WINAPI CIOCPServer::_WorkerThreadProc(LPVOID lpParam)
{
#ifdef _DEBUG
::OutputDebugString(" WorkerThread 启动... \n");
#endif // _DEBUG


CIOCPServer *pThis = (CIOCPServer*)lpParam;


CIOCPBuffer *pBuffer = NULL;
DWORD dwKey;
DWORD dwTrans;
LPOVERLAPPED lpol;


while(TRUE)
{
// 在关联到此完成端口的所有套节字上等待I/O完成
BOOL bOK = ::GetQueuedCompletionStatus(pThis->m_hCompletion,
&dwTrans, (LPDWORD)&dwKey, (LPOVERLAPPED*)&lpol, WSA_INFINITE);

if(dwTrans == -1) // 用户通知退出
{
#ifdef _DEBUG
::OutputDebugString(" WorkerThread 退出 \n");
#endif // _DEBUG
::ExitThread(0);
}
if(dwTrans != -2)
pBuffer = CONTAINING_RECORD(lpol, CIOCPBuffer, ol);
int nError = NO_ERROR;
if(!bOK) // 在此套节字上有错误发生
{
printf("完成端口套接字上有错误：%d\n",GetLastError());
SOCKET s;
if(pBuffer->nOperation == OP_ACCEPT)
{
s = pThis->m_sListen;
}
else
{
if(dwKey == 0)
break;
s = ((CIOCPContext*)dwKey)->s;
}
DWORD dwFlags = 0;
if(!::WSAGetOverlappedResult(s, &pBuffer->ol, &dwTrans, FALSE, &dwFlags))
{
nError = ::WSAGetLastError();
}
}
pThis->HandleIO(dwKey, pBuffer, dwTrans, nError);
printf("Buffer:%d Context:%d\n",iBufferCount,iContextCount);
}


#ifdef _DEBUG
::OutputDebugString(" WorkerThread 退出 \n");
#endif // _DEBUG
return 0;
}


int g_x = 0;
void CIOCPServer::HandleIO(DWORD dwKey, CIOCPBuffer *pBuffer, DWORD dwTrans, int nError)
{
CIOCPContext *pContext = (CIOCPContext *)dwKey;


#ifdef _DEBUG
::OutputDebugString(" HandleIO... \n");
#endif // _DEBUG

// 1）首先减少套节字上的未决I/O计数
if(dwTrans == -2)
{
CloseAConnection(pContext);
return;
}
if(pContext != NULL)
{
::EnterCriticalSection(&pContext->Lock);

if(pBuffer->nOperation == OP_READ)
pContext->nOutstandingRecv --;
else if(pBuffer->nOperation == OP_WRITE)
pContext->nOutstandingSend --;

::LeaveCriticalSection(&pContext->Lock);

// 2）检查套节字是否已经被我们关闭
if(pContext->bClosing)
{
#ifdef _DEBUG
::OutputDebugString(" 检查到套节字已经被我们关闭 \n");
#endif // _DEBUG
if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
// 释放已关闭套节字的未决I/O
ReleaseBuffer(pBuffer);
pBuffer = NULL;
return;
}
}
else
{
RemovePendingAccept(pBuffer);
}


// 3）检查套节字上发生的错误，如果有的话，通知用户，然后关闭套节字
if(nError != NO_ERROR)
{
if(pBuffer->nOperation != OP_ACCEPT)
{
OnConnectionError(pContext, pBuffer, nError);
CloseAConnection(pContext);
if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
#ifdef _DEBUG
::OutputDebugString(" 检查到客户套节字上发生错误 \n");
#endif // _DEBUG
}
else // 在监听套节字上发生错误，也就是监听套节字处理的客户出错了
{
// 客户端出错，释放I/O缓冲区
if(pBuffer->sClient != INVALID_SOCKET)
{
::closesocket(pBuffer->sClient);
pBuffer->sClient = INVALID_SOCKET;
}
#ifdef _DEBUG
::OutputDebugString(" 检查到监听套节字上发生错误 \n");
#endif // _DEBUG
}


ReleaseBuffer(pBuffer);
pBuffer = NULL;
return;
}




// 开始处理
if(pBuffer->nOperation == OP_ACCEPT)
{
if(dwTrans == 0)
{
#ifdef _DEBUG
::OutputDebugString(" 监听套节字上客户端关闭 \n");
#endif // _DEBUG

if(pBuffer->sClient != INVALID_SOCKET)
{
::closesocket(pBuffer->sClient);
pBuffer->sClient = INVALID_SOCKET;
}
}
else
{
// 为新接受的连接申请客户上下文对象
CIOCPContext *pClient = AllocateContext(pBuffer->sClient);
if(pClient != NULL)
{
if(AddAConnection(pClient))
{
// 取得客户地址
int nLocalLen, nRmoteLen;
LPSOCKADDR pLocalAddr, pRemoteAddr;
m_lpfnGetAcceptExSockaddrs(
pBuffer->buff,
pBuffer->nLen - (sizeof(sockaddr_in) + 16) * 2/*sizeof(cmd_header)*/,
sizeof(sockaddr_in) + 16,
sizeof(sockaddr_in) + 16,
(SOCKADDR **)&pLocalAddr,
&nLocalLen,
(SOCKADDR **)&pRemoteAddr,
&nRmoteLen);
memcpy(&pClient->addrLocal, pLocalAddr, nLocalLen);
memcpy(&pClient->addrRemote, pRemoteAddr, nRmoteLen);

// 关联新连接到完成端口对象
::CreateIoCompletionPort((HANDLE)pClient->s, m_hCompletion, (DWORD)pClient, 0);

// 通知用户
pBuffer->nLen = dwTrans;
OnConnectionEstablished(pClient, pBuffer);


if(pClient->bClosing && pClient->nOutstandingRecv == 0 && pClient->nOutstandingSend == 0)
{
ReleaseContext(pClient);
pContext = NULL;
}
else if(pClient->hTimer == NULL)//接收一个客户端的同时创建一个检测I/O超时的Timer
{
pClient->hCompletion = m_hCompletion;
CreateTimerQueueTimer(&pClient->hTimer,m_hTimerQueue,(WAITORTIMERCALLBACK)TimerRoutine,(PVOID)pClient,60*1000,0,0);
}

// 向新连接投递Read请求或者Write请求，直接关闭这些空间在套节字关闭或出错时释放
// CIOCPBuffer *p = AllocateBuffer(BUFFER_SIZE);
// if(p != NULL)
// {
// if(!PostRecv(pClient, p))
// {
// CloseAConnection(pClient);
// }
// }


}
else // 连接数量已满，关闭连接
{
CloseAConnection(pClient);
ReleaseContext(pClient);
pContext = NULL;
}
}
else
{
// 资源不足，关闭与客户的连接即可
::closesocket(pBuffer->sClient);
pBuffer->sClient = INVALID_SOCKET;
}
}

// Accept请求完成，释放I/O缓冲区
ReleaseBuffer(pBuffer);
pBuffer = NULL;


// 通知监听线程继续再投递一个Accept请求
::InterlockedIncrement(&m_nRepostCount);


::SetEvent(m_hRepostEvent);
}
else if(pBuffer->nOperation == OP_READ)
{
if(dwTrans == 0) // 对方关闭套节字
{
// 先通知用户
pBuffer->nLen = 0;
OnConnectionClosing(pContext, pBuffer);
// 再关闭连接
CloseAConnection(pContext);
// 释放客户上下文和缓冲区对象
if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
ReleaseBuffer(pBuffer);
pBuffer = NULL;
}
else
{
pBuffer->nLen = dwTrans;
// 按照I/O投递的顺序读取接收到的数据
CIOCPBuffer *p = GetNextReadBuffer(pContext, pBuffer);
while(p != NULL)
{
// 通知用户
OnReadCompleted(pContext, p);
// 增加要读的序列号的值
::InterlockedIncrement((LONG*)&pContext->nCurrentReadSequence);
// 释放这个已完成的I/O
ReleaseBuffer(p);
p = GetNextReadBuffer(pContext, NULL);
}


if(pContext->bClosing && pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
else if(pContext->hTimer != NULL)
{
ChangeTimerQueueTimer(m_hTimerQueue,pContext->hTimer,60*1000,0);//重置监视时间，当一个投递完成后，60s内无任何交互则断开。
}


// 继续投递一个新的接收请求
// pBuffer = AllocateBuffer(BUFFER_SIZE);
//if(pBuffer == NULL || !PostRecv(pContext, pBuffer))
//{
// CloseAConnection(pContext);
//}
}
}
else if(pBuffer->nOperation == OP_WRITE)
{


if(dwTrans == 0) // 对方关闭套节字
{
// 先通知用户
pBuffer->nLen = 0;
OnConnectionClosing(pContext, pBuffer);


// 再关闭连接
CloseAConnection(pContext);


// 释放客户上下文和缓冲区对象
if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
ReleaseBuffer(pBuffer);
pBuffer = NULL;
}
else
{
if(pContext->bClosing && pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
ReleaseBuffer(pBuffer);
pBuffer = NULL;
return;
}
else if(pContext->hTimer != NULL)
{
ChangeTimerQueueTimer(m_hTimerQueue,pContext->hTimer,60*1000,0);
}


// 写操作完成，通知用户
if(dwTrans < pBuffer->nLen)//如果此send没有发送完全，则发送剩下的部分（此部分如果还是没发完全，这里同样进行）
{
printf("send未发送完全，发送：%d，总长度：%d\n",dwTrans,pBuffer->nLen);
CIOCPBuffer* p = AllocateBuffer(pBuffer->nLen - dwTrans);
if(p != NULL)
memcpy(p->buff,pBuffer->buff + dwTrans,pBuffer->nLen - dwTrans);
if(p == NULL || !PostSend(pContext,p))
{
CloseAConnection(pContext);
return;
}
}
else
{
if(!PostNextWriteBuffer(pContext,pBuffer))
{
CloseAConnection(pContext);
return;
}
}
pBuffer->nLen = dwTrans;
OnWriteCompleted(pContext, pBuffer);
if(pContext->bClosing && pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
{
ReleaseContext(pContext);
pContext = NULL;
}
// 释放SendText函数申请的缓冲区
ReleaseBuffer(pBuffer);
pBuffer = NULL;
}
}
}




BOOL CIOCPServer::SendText(CIOCPContext *pContext, char *pszText, int nLen)
{
CIOCPBuffer *pBuffer = AllocateBuffer(nLen);
if(pBuffer != NULL)
{
memcpy(pBuffer->buff, pszText, nLen);
return PostSend(pContext, pBuffer);
}
return FALSE;
}


//投递接收请求示例
//CIOCPBuffer *p = AllocateBuffer(BUFFER_SIZE);
//if(p != NULL)
//{
// if(!PostRecv(pContext, p))
// {
// CloseAConnection(pContext);
// }
//}
//投递发送请求示例
//CIOCPBuffer *p = AllocateBuffer(BUFFER_SIZE);
//if(p != NULL)
//{
// if(!PostSendToList(pContext, p))
// {
// CloseAConnection(pContext);
// }
//}
void CIOCPServer::OnConnectionEstablished(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
//连接建立，且第一次数据接收完成。
//接下来可以根据业务逻辑，PostRecv收或者PostSendToList发或者CloseAConnection(pContext)关闭连接
}


void CIOCPServer::OnConnectionClosing(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
}


void CIOCPServer::OnReadCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
//一次数据接收完成。
//接下来可以根据业务逻辑，PostRecv收或者PostSendToList发或者CloseAConnection(pContext)关闭连接
}


void CIOCPServer::OnWriteCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
{
//一次数据发送完成。
//接下来可以根据业务逻辑，PostRecv收或者PostSendToList发或者CloseAConnection(pContext)关闭连接
}


void CIOCPServer::OnConnectionError(CIOCPContext *pContext, CIOCPBuffer *pBuffer, int nError)
{
}

你可能感兴趣的:(7种网络编程I/O模型代码实现实例)

《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情迷影咖啡
作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
亲子日记之祝姑姥姥生日快乐（282）冰心雨露_d504
2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
100天30本书读书计划（2018-06-11）DAY 62 一个姜姜
【书名】当我谈跑步时，我谈些什么【作者】村上春树【读书页数】51--128/187【读书时间】2018年6月11日【精彩句子】01肌肉难长，易消。赘肉易长，难消。P5502肌肉也同有血有肉的动物一般无二，它也愿意过更舒服的日子，不继续给它负荷，它便会心安理得地将记忆出去。想再度输入的话，必须得从头开始，将同样的模式重复一遍。P7703不管怎样，反正得坚持跑步。每天跑步对我来说好比生命线，不能说忙就
数据结构奇妙旅程之深入解析快速排序山间漫步人生路数据结构排序算法算法
快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
教育微创新的意蕴知北老师
我是1992年参加工作的，一毕业就被分配到一所全县最偏僻落后的农村学校——付窝中学，12年后被调往一所已经连续十年全县倒数第一，也是很偏僻落后的农村学校——北宋镇第三中学。三年后到了北宋镇第一中学工作，这所学校教学质量也是连续几年落后了。2014年我到了北京市育英学校，这所学校是京城名校。2016年7月，我被育英学校派往原密云区第七中学工作，这是一所城乡接合部薄弱学校。学校现名为北京市育英学校密云
Flink中的SQL Client和SQL Gateway BigDataMLApplication flink flink sql gateway
Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
打印出1-100的奇数。（C语言）王多鱼001 C语言 c语言算法数据结构
代码：#includeintmain(){for(inti=1;i<101;i++){if(i%2==1){printf("%d,",i);}}return0;}
通俗易懂：MySQL中如何设置只读实例并确保数据一致性？大龄下岗程序员 mysql java mysql spring
在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
LeetCode1047：删除字符串中的所有相邻重复项一个小猴子｀ LeetCode 算法数据结构 c++leetcode
题目描述给出由小写字母组成的字符串S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在S上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。示例：输入：“abbaca”输出：“ca”解释：例如，在“abbaca”中，我们可以删除“bb”由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串“aaca”，其中又只有“a
word字号和mathtype磅值关系及批量修改小铁匠-Ma office小技巧经验分享
word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
读思001 ‖ 变负能为正能，变压力为动力你不懂夜的黑
今天起开始写一个言说文集连载，重点为读写思考收获和感想，也收录生活和工作中开悟到的点滴，仍然是一个碎片式的思考积累。希望这样的思考能启迪我的生活智慧，开悟我的思想境界，也算是一个修心的过程吧。这个连载不定期更新，重在积累生活和工作中的随思碎思，或许也是一厢情愿的一个梦。也或许这个梦是我坚持说下去的一个重要理由。读思001变负能为正能，变压力为动力1从来没有一种哲学能解决一切问题，也从来没有一种药能
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
php 把一个数组分成有n个元素的二维数组的算法风清扬-独孤九剑 php php 算法
一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
花气袭人知昼暖柒侠传
花气袭人知昼暖高一七班黄韵熹37号花袭人，原名花珍珠，位列金陵十二钗又副册中的第二位。“袭人”这一称呼源于“花气袭人知昼暖”这一诗句，是宝玉给起的。想起来便觉得暖融融的，一如花袭人温柔的笑容。但花袭人着实是令人又爱又怕的角色。第二十一回的回目将她赞作“贤袭人”，脂砚斋在一旁批道“当得起”。花袭人对宝玉的确是一片真心。她为劝宝玉收敛他那成日在大观园里与姐姐妹妹“厮混”的性子，假借家人赎回的机会，软语
感恩日志圆施
张新丽2019年8月16日感恩日志：1.感恩天地滋养万物；感恩国家恩惠护佑；感恩父母养育深恩。2.感恩尊重为平台源头付出的所有人事物。3.感恩红斌、孙萍清晨7点开车来接我和小姨去安宁渠采摘。4.感恩小姨和小姨夫亲自采摘还带我们去瓜地品尝，第一次这么吃好甜啊，忘掉了炎热消了暑，拍下了瞬间，分享着快乐，带给大家。4.感恩整理收拾好小姨给大家利用午休蒸苞米。5.感恩去接爸妈参加沙龙。6.感恩祝福两位伙伴
llama.cpp 编译安装@Ubuntu skywalk8163 项目实践人工智能 llama ubuntu linux 人工智能
在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
python 推导式(派生、衍生) sanduo112 人工智能 python windows 开发语言
python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
SpringMVC设置全局异常处理器水岸齐天 java spring
文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
为什么说仪式和习惯非常重要？章鱼老师zy
这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
安神的投资札记——指数跟踪周报（20220602） echo安神
本周关键词：缩表上周调整过后，本周又反弹了。最近创业板好活跃，跌的时候跌得凶，涨的时候也涨得猛。底部特征明显。上证50，0.99%；沪深300，2.21%；中证100，1.85%；中证500，3.03%；深证100，3.71%；创业板指数，5.85%；中证1000，3.75%。美联储6月1日开启缩表，每月总计减持475亿美元美国国债和MBS（抵押贷款支持证券），并将在3个月后提高缩表上限至每月95
手机上赚钱？学会这5种方法！高省app让你轻松赚钱！高省浮沉000018
随着智能手机的普及，越来越多的人开始探索在手机上赚钱的方法。不仅可以利用碎片时间增加收入，还能减少对传统办公室工作的依赖。本文将向您介绍5种在手机上赚钱的方法，并推荐一款高省app，帮助您实现手机赚钱的目标。大家好！我是高省APP最大团队&联合创始人浮沉导师！【高省】APP网购优惠券免费领，分享还能赚钱。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台。佣金更高，模式更好，终端用户不流失。0投资
12-25 yummy0632
72.4kg早饭：一碗面条，俩鸡蛋，三个砂糖桔。五天过去了，这本书我听完了。哈哈简直了。真兴奋，我准备好了，迎接新的自己。午饭：一个花卷，一碗汤，一份油菜，一份冬瓜粉条，一份红烧肉。晚饭：一个花卷，一份芹菜，一份土豆，一份鸭子。很咸。
数据分析：低代码平台助力大数据时代的飞跃发展快乐非自愿数据分析低代码大数据
随着信息技术的突飞猛进，我们身处于一个数据量空前增长的时代——大数据时代。在这个时代背景下，数据分析已经成为企业决策、政策制定、科学研究等众多领域不可或缺的重要工具。然而，面对海量的数据和日益复杂多变的分析需求，传统的数据分析方法往往捉襟见肘，难以应对。幸运的是，低代码平台的兴起为大数据分析注入了新的活力，成为推动大数据时代发展的重要力量。低代码平台，顾名思义，是一种通过少量甚至无需编写代码，就能
有一种失去叫做得不到野风狂生
图片发自App有一种失去叫做得不到野风狂生（20190130）有一种失去叫做得不到失去的是希望是前进的方向是奋斗的动力是奇迹的召唤纵然有一天将其释怀遗憾的残迹却永留心底得不到有时也会心痛仿佛沙漠里远望着的一泓甘泉十米处被他人喝干涸仿佛黑洞里疲惫追逐的火焰在握住前一秒耗尽光明仿佛风雪彻骨的冬天被人剥剩至赤裸而夜行山莽埋葬未曾示面的野心有谁还会去祭奠不用问我问我也无可奉告不用问你问你也缄默不言去拥抱那
2022-10-02 朗月斋主
肿瘤溶解病毒（OVs）作为一种新型的免疫治疗和治疗辅助剂，在制药行业中越来越受到关注，因为它们能够通过多种机制诱导和提高抗肿瘤免疫力。首先，OVs能够利用宿主免疫系统的内在机制（例如，逃避免疫检测）可以使肿瘤的免疫逃逸机制失效。第二，许多类型的OVs已被证明可以直接裂解肿瘤细胞，从而诱导出由肿瘤相关抗原和危险信号分子释放介导的肿瘤特异性T细胞反应。第三，表达免疫刺激治疗基因的武装OV可以在肿瘤组织
购物返利平台是真的吗返金app平台高佣返利省钱
购物返利平台是真实存在的，它们提供一种通过购物来获取一定比例返现的服务。这些平台通常与商家合作，通过返利链接或其他追踪方式来追踪用户的购物行为，然后将一部分返现金额返还给用户。然而，需要注意的是，并非所有的购物返利平台都是可信的。在选择使用购物返利平台时，建议您注意以下几个方面：可信度和口碑：查看平台的用户评价和口碑，了解其他用户对该平台的使用体验和返利情况。合作商家：了解平台的合作商家是否可靠，
1.计算机处理器架构+嵌入式处理器架构及知识 vv 啊 arm-linux学习 linux 系统架构
目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
零元购晋迪
初听到零元购这个词，我们都感觉好奇。同事老王收到一条快递取件码的短信，可她清楚记得自己最近并没有买东西。快递公司给她打来电话让她去取件，听明白后，她才知道是怎么回事。原来有天闲着没事，她在拼多多上看到有个零元购，出于好奇，她进去看了，不小心点到一个商品，可当时也没用付钱，她并不知道这样就算下单了，今天收到快递公司的电话，她去查看，竟然自动扣款了。商家可能琢磨到人性的弱点，干脆发明这么一种销售方式，
200719：重拾优点？问谁逝舟
小时候的哪些优点，现在想重新拾回？——题记：《惜福阅历（SisypheCalendar）》2020.01.04还是先来审题吧。这句话中的关键信息就在于“重拾小时候的优点”。小时候的优点，当然是在曾经的生活中，给我们带来过好处，有其被自己或是被社会认可的价值。而它跟“重拾”搭配在一起，就颇耐人寻味了。重拾，意味着曾经失落，也意味着它对当下还有价值。那么问题来了，既然曾经它是有价值的，既然对当下还有价
springboot集成logback-spring.xml文件 RT_0114 SpringBoot spring boot spring logback
彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&