DELPHI高性能大容量SOCKET并发.docx

DELPHI高性能大容量SOCKET并发.docx

《DELPHI高性能大容量SOCKET并发.docx》由会员分享，可在线阅读，更多相关《DELPHI高性能大容量SOCKET并发.docx（60页珍藏版）》请在冰豆网上搜索。

DELPHI高性能大容量SOCKET并发

DELPHI高性能大容量SOCKET并发

（一）：

IOCP完成端口例子介绍

例子主要包括IOCP控件封装、服务端实现、传输协议和日志、控制、SQL查询、上传、下载等协议实现，并包括一些初步的性能测试结果。

服务端：

界面截图如下：

提供服务和桌面方式运行，桌面方式可直接打开程序，方便日常调试，可以使用命令行注册或卸载服务，在CMD中输入D:

\DEMO\IOCPDemo\Bin\IOCPDemoSvr.exe-install来注册服务，在CMD输入D:

\DEMO\IOCPDemo\Bin\IOCPDemoSvr.exe-uninstall来卸载服务。

客户端：

界面截图如下：

主要实现了服务端日志查看，服务端协议类表查看，SQL语句执行协议，上传、下载协议实现，其中对上传、下载实现了一个多线程同时传，用于测试服务器并发性能。

性能：

支持超过2000个链接及以上同时上传文件，不过每个连接上传速度只有1到2K。

支持超过2W个连接同时在线传输命令。

单实例上传下载测试结果：

从测试结果可以看出随着发送包增大，速度变快。

这里存在一个风险，就是SOCKET传输失败的次数也会增加。

（二）：

IOCP完成端口控件封装

IOCP完成端口介绍：

完成端口模型是Windows平台下SOCKET端口模型最为复杂的一种I/O模型。

如果一个应用程序需要同时管理为数众多的套接字，而且希望随着系统内安装的CPU数量的增多，应用程序的性能也可以线性提升，采用完成端口模型，往往可以达到最佳的系统性能。

完成端口可以管理成千上万的连接，长连接传文件可以支持5000个以上，长连接命令交互可以支持20000个以上。

这么大并发的连接，更需要考虑的是应用场景，按照100M的网卡传输速度12.5MB/S，如果是5000个传文件连接，则每个连接能分到的速度2.56KB/S；如果是20000个命令交互连接，则每个连接分到的吞吐量是655B/S，这种速度的吞吐量对很多应用是不满足，这时就要考虑加大网卡的传输速度或实现水平扩展，这个我们后续会介绍。

完成端口是由系统内核管理多个线程之间的切换，比外部实现线程池性能要高，CPU利用率上内核和用户态可以达到1:

1，很多应用线程池是无法达到的。

因此同等连接数的情况下，完成端口要比INDY的TCPServer传输速度要快，吞吐量更高。

要使用完成端口，主要是以下三个函数的使用：

CreateIoCompletionPort、GetQueuedCompletionStatus、PostQueuedCompletionStatus。

CreateIoCompletionPort的功能是：

1、创建一个完成端口对象；2、将一个句柄和完成端口关联在一起；GetQueuedCompletionStatus是获取完成端口状态，是阻塞式调用，在指定时间内如果没有事件通知，会一直等待；PostQueuedCompletionStatus用于向完成端口投递一个完成事件通知。

functionCreateIoCompletionPort（FileHandle,ExistingCompletionPort:

THandle;CompletionKey,NumberOfConcurrentThreads:

DWORD）:

THandle;stdcall;NumberOfConcurrentThreads参数定义了在一个完成端口上，同时允许执行的线程数量。

将NumberOfConcurrentThreads设为0表示每个处理器各自负责一个线程的运行，为完成端口提供服务，避免过于频繁的线程场景切换。

因此可以使用下列语句来创建一个完成端口FIocpHandle:

=CreateIoCompletionPort（INVALID_HANDLE_VALUE,0,0,0）;

执行线程个数

创建完成端口后，就可以将套接字句柄与对象关联在一起，这时就需要创建工作者线程，以便在完成端口收到数据后，为完成端口提供处理数据线程。

到底创建多少个线程为完成端口服务，这个是完成端口最为复杂的一方面，创建多了线程会造成频繁的线程场景切换；创建少了线程如果某一个处理非常耗时，如连接数据库、读写文件，又会造成完成端口拥塞，因此这个参数需要提供设置，并根据最终的应用场景反复测试得出一个结果。

一般的经验值是设置为CPU的个数*2+4；

IOCP完成端口一般使用步骤

1、创建一个完成端口；

2、判断系统内安装了多少个处理器；

3、创建工作者线程；

4、创建一个SOCKET套接字开始监听；

5、使用Accept接收连接；

6、调用CreateIoCompletionPort将连接和完成端口绑定在一起；

7、投递接收数据请求

8、工作者线程调用GetQueuedCompletionStatus获取事件通知，处理数据；

IOCP控件核心代码

第1步到第4步实现代码：

[delphi] viewplaincopy

1.procedure TIocpServer.Open;  

2.var  

3.  WsaData:

 TWsaData;  

4.  iNumberOfProcessors, i, iWorkThreadCount:

 Integer;  

5.  WorkThread:

 TWorkThread;  

6.  Addr:

 TSockAddr;  

7.begin  

8.  if WSAStartup（$0202, WsaData） <> 0 then  //初始化SOCKET  

9.    raise ESocketError.Create（GetLastWsaErrorStr）;  

10.  FIocpHandle :

= CreateIoCompletionPort（INVALID_HANDLE_VALUE, 0, 0, 0）;  //创建一个完成端口  

11.  if FIocpHandle = 0 then  

12.    raise ESocketError.Create（GetLastErrorStr）;  

13.  FSocket :

= WSASocket（PF_INET, SOCK_STREAM, 0, nil, 0, WSA_FLAG_OVERLAPPED）; //创建一个SOCKET句柄  

14.  if FSocket = INVALID_SOCKET then  

15.    raise ESocketError.Create（GetLastWsaErrorStr）;  

16.  FillChar（Addr, SizeOf（Addr）, 0）;  

17.  Addr.sin_family :

= AF_INET;  

18.  Addr.sin_port :

= htons（FPort）;  

19.  Addr.sin_addr.S_addr :

= htonl（INADDR_ANY）; //在任何地址上监听，如果有多块网卡，会每块都监听，也可以指定只监听某一个IP地址  

20.  if bind（FSocket, @Addr, SizeOf（Addr）） <> 0 then //把SOCKET句柄绑定端口  

21.    raise ESocketError.Create（GetLastWsaErrorStr）;  

22.  if listen（FSocket, MaxInt） <> 0 then   

23.     raise ESocketError.Create（GetLastWsaErrorStr）;  

24.  iNumberOfProcessors :

= GetCPUCount; //获取CPU个数  

25.  iWorkThreadCount :

= iNumberOfProcessors * 2 + 4; //由于服务器处理可能比较费时间，因此线程设为CPU*2+4  

26.  if iWorkThreadCount < FMinWorkThrCount then //限定最大工作者线程和最小工作者线程  

27.    iWorkThreadCount :

= FMinWorkThrCount;  

28.  if iWorkThreadCount > FMaxWorkThrCount then  

29.    iWorkThreadCount :

= FMaxWorkThrCount;  

30.  for i :

= 0 to iWorkThreadCount - 1 do //创建工作者线程  

31.  begin  

32.    WorkThread :

= TWorkThread.Create（Self, True）;  

33.    FWorkThreads.Add（WorkThread）;  

34.    WorkThread.Resume;  

35.  end;  

36.  FAcceptThreadPool.Active :

= True; //启动监听线程池  

37.  FAcceptThread :

= TAcceptThread.Create（Self, True）; //启动监听线程  

38.  FAcceptThread.Resume;  

39.end;  

第5步和第6步实现代码：

[delphi] viewplaincopy

1.procedure TIocpServer.AcceptClient;  

2.var  

3.  ClientSocket:

 TSocket;  

4.begin  

5.  ClientSocket :

= WSAAccept（FSocket, nil, nil, nil, 0）; //接收连接  

6.  if ClientSocket <> INVALID_SOCKET then  

7.  begin  

8.    if not FActive then  

9.    begin  

10.      closesocket（ClientSocket）;  

11.      Exit;  

12.    end;  

13.    FAcceptThreadPool.PostSocket（ClientSocket）; //这里使用线程池主要作用是为了判断发送的第一个字节身份标识，用来是判断协议类型  

14.  end;  

15.end;  

FAcceptThreadPool是一个用完成端口实现的线程池TIocpThreadPool，主要是有TCheckThread来判断完成端口的返回，并检测是否6S内有发送标志位上来，主要实现过程是响应OnConnect事件，并在OnConnect事件中判断是否允许连接。

[delphi] viewplaincopy

1.procedure TIocpServer.CheckClient（const ASocket:

 TSocket）;  

2.var  

3.  SocketHandle:

 TSocketHandle;  

4.  iIndex:

 Integer;  

5.  ClientSocket:

 PClientSocket;  

6.begin  

7.  SocketHandle :

= nil;  

8.  if not DoConnect（ASocket, SocketHandle） then //如果不允许连接，则退出  

9.  begin  

10.    closesocket（ASocket）;  

11.    Exit;  

12.  end;  

13.  FSocketHandles.Lock; //加到列表中  

14.  try  

15.    iIndex :

= FSocketHandles.Add（SocketHandle）;  

16.    ClientSocket :

= FSocketHandles.Items[iIndex];  

17.  finally  

18.    FSocketHandles.UnLock;  

19.  end;  

20.  if CreateIoCompletionPort（ASocket, FIOCPHandle, DWORD（ClientSocket）, 0） = 0 then //将连接和完成端口绑定在一起  

21.  begin  

22.    DoError（'CreateIoCompletionPort', GetLastWsaErrorStr）;  

23.    FSocketHandles.Lock; //如果投递到列表中失败，则删除  

24.    try  

25.      FSocketHandles.Delete（iIndex）;  

26.    finally  

27.      FSocketHandles.UnLock;  

28.    end;  

29.  end  

30.  else  

31.  begin  

32.    SocketHandle.PreRecv（nil）; //投递接收请求  

33.  end;  

34.end;  

[delphi] viewplaincopy

1.procedure TDMDispatchCenter.IcpSvrConnect（const ASocket:

 Cardinal;  

2.  var AAllowConnect:

 Boolean; var SocketHandle:

 TSocketHandle）;  

3.var  

4.  BaseSocket:

 TBaseSocket;  

5.  chFlag:

 Char;  

6.  

7.  function GetSocket（const AEnable:

 Boolean; BaseSocketClass:

 TBaseSocketClass）:

 TBaseSocket;  

8.  begin  

9.    if AEnable then  

10.      Result :

= BaseSocketClass.Create（IcpSvr, ASocket）  

11.    else  

12.      Result :

= nil;  

13.  end;  

14.begin  

15.  if （GIniOptions.MaxSocketCount > 0） and （IcpSvr.SocketHandles.Count >= GIniOptions.MaxSocketCount） then  

16.  begin  

17.    AAllowConnect :

= False;  

18.    Exit;  

19.  end;  

20.  if IcpSvr.ReadChar（ASocket, chFlag, 6*1000） then //必须在6S内收到标志  

21.  begin  

22.    case TSocketFlag（Byte（chFlag）） of  

23.      sfSQL:

 BaseSocket :

= GetSocket（GIniOptions.SQLProtocol, TSQLSocket）;  

24.      sfUpload:

 BaseSocket :

= GetSocket（GIniOptions.UploadProtocol, TUploadSocket）;  

25.      sfDownload:

 BaseSocket :

= GetSocket（GIniOptions.DownloadProtocol, TDownloadSocket）;  

26.      sfControl:

 BaseSocket :

= GetSocket（GIniOptions.ControlProtocol, TControlSocket）;  

27.      sfLog:

 BaseSocket :

= GetSocket（GIniOptions.LogProtocol, TLogSocket）;  

28.    else  

29.      BaseSocket :

= nil;;  

30.    end;  

31.    if BaseSocket <> nil then  

32.    begin  

33.      SocketHandle :

= BaseSocket;  

34.      WriteLogMsg（ltDebug, Format（'Client Connect, Local Address:

 %s:

%d; Remote Address:

 %s:

%d',  

35.        [SocketHandle.LocalAddress, SocketHandle.LocalPort, SocketHandle.RemoteAddress, SocketHandle.RemotePort]））;  

36.      WriteLogMsg（ltDebug, Format（'Client Count:

 %d', [IcpSvr.SocketHandles.Count + 1]））;  

37.      AAllowConnect :

= True;  

38.    end  

39.    else  

40.      AAllowConnect :

= False;  

41.  end  

42.  else  

43.    AAllowConnect :

= False;  

44.end;  

其中ReadChar函数是用于判断指定时间是否有数据上来，函数实现过程用Select函数检测：

[delphi] viewplaincopy

1.function TIocpServer.ReadChar（const ASocket:

 TSocket; var AChar:

 Char; const ATimeOutMS:

 Integer）:

 Boolean;  

2.var  

3.  iRead:

 Integer;  

4.begin  

5.  Result :

= CheckTimeOut（ASocket, ATimeOutMS）;  

6.  if Result then  

7.  begin  

8.    iRead :

= recv（ASocket, AChar, 1, 0）;  

9.    Result :

= iRead = 1;   

10.  end;  

11.end;  

12.  

13.function TIocpServer.CheckTimeOut（const ASocket:

 TSocket;  

14.  const ATimeOutMS:

 Integer）:

 Boolean;  

15.var  

16.  tmTo:

 TTimeVal;  

17.  FDRead:

 TFDSet;  

18.begin  

19.  FillChar（FDRead, SizeOf（FDRead）, 0）;  

20.  FDRead.fd_count :

= 1;  

21.  FDRead.fd_array[0] :

= ASocket;  

22.  tmTo.tv_sec :

= ATimeOutMS div 1000;  

23.  tmTo.tv_usec :

= （ATimeOutMS mod 1000） * 1000;  

24.  Result :

= Select（0, @FDRead, nil, nil, @tmTO） = 1;  

25.end;  

第7步实现代码

接收连接之后要投递接收数据请求，实现代码：

[delphi] viewplaincopy

1.procedure TSocketHandle.PreRecv（AIocpRecord:

 PIocpRecord）;  

2.var  

3.  iFlags, iTransfer:

 Cardinal;  

4.  iErrCode:

 Integer;  

5.begin  

6.  if not Assigned（AIocpRecord） then  

7.  begin  

8.    New（AIocpRecord）;  

9.    AIocpRecord.WsaBuf.buf :

= @FIocpRecvBuf;  

10.    AIocpRecord.WsaBuf.len :

= MAX_IOCPBUFSIZE;  

11.    FIocpRecv :

= AIocpRecord;  

12.  end;  

13.  AIocpRecord.Overlapped.Internal :

= 0;  

14.  AIocpRecord.Overlapped.InternalHigh :

= 0;  

15.  AIocpRecord.Overlapped.Offset :

= 0;  

16.  AIocpRecord.Overlapped.OffsetHigh :

= 0;  

17.  AIocpRecord.Overlapped.hEvent :

= 0;  

18.  //AIocpRecord.WsaBuf.buf :

= @FIocpRecvBuf;  

19.  //AIocpRecord.WsaBuf.len :

= MAX_IOCPBUFSIZE;  

20.  AIocpRecord.IocpOperate :

= ioRead;  

21.  iFlags :

= 0;  

22.  if WSARecv（FSocket, @AIocpRecord.WsaBuf, 1, iTransfer, iFlags, @AIocpRecord.Overlapped,  

23.    nil） = SOCKET_ERROR then  

24.  begin  

25.    iErrCode :

= WSAGetLastError;  

26.    if iErrCode = WSAECONNRESET then //客户端被关闭  

27.      FConnected :

= False;  

28.    if iErrCode <> ERROR_IO_PENDING then //不抛出异常，触发异常事件  

29.    begin  

30.      FIocpServer.DoError（'WSARecv', GetLastWsaErrorStr）;  

31.      ProcessNetError（iErrCode）;  

32.    end;  

33.  end;  

34.end;  

第8步实现代码：

[delphi] viewplaincopy

1.function TIocpServer.WorkClient:

 Boolean;  

2.var  

3.  ClientSocket:

 PClientSocket;  

4.  IocpRecord:

 PIocpRecord;  

5.  iWorkCount:

 Cardinal;  

6.begin