IOCP (关于WSASend，WSARecv调用)

最新推荐文章于 2020-11-26 11:27:38 发布
最新推荐文章于 2020-11-26 11:27:38 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： IOCP 文章标签： WSASend WSARecv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangqin115/article/details/78474631
版权

最近都在做windows socket相关的东西，使用IOCP其中还是遇到了一些问题，当然遇到问题就要尝试解决问题，这也是一个学习的过程。

IOCP可以说是windows 上性能最好的网络模型了，具体IOCP，就不介绍了.在用我的网络接口，发大量数据时，发现，数据对不上，即收包量会增多，内容是不会丢的，由于我是严格控制服务器端的收包大小，和收包量，所以也感觉很奇怪。

先是怀疑WSASend连续调用，会有问题，但大致看了看这篇文章（http://bbs.pediy.com/showthread.php?p=826108），这文章写的很给力，所以又觉得不会有问题，于是我就自己开始写了一个测试程序。

当然也不是写了就马上能发现问题，调了一下午加一个晚上，发现了问题所在。

问题在WSARecv，这个东西它居然没填满我要求的缓存，就给完成端口发了通知，导致客户端发过来的数据，被截开了，所以包的数量就增加了，但是由于是TCP，所以内容，顺序都没问题。

接下来说说如何解决问题：

BOOL bIORet = GetQueuedCompletionStatus(CompPort,

                                    &dwIoSize,

                                    (LPDWORD)&pCompletionKey,

                                    &lpOverlapped,

                                    INFINITE);

关键看第二个参数，dwIoSize,它告诉你，你实际接收到了多少数据，通过它，你就应该知道还要继续接受多少数据了吧，明白人，应该就知道该如何做了，不明白的看我的代码吧。

 

注意：WSARecv，最好不要连续调用，特别是在多线程里连续调用，因为后果可能会无法预料，这个应该还是根据需求而定，也许有的情况下可以。

 

剩下的就是贴代码了，时间紧任务重，加上本人比较水，所以代码质量不高，多多包涵，同时还请各位朋友给出建议，提出批评，大家一起学习，共同进步。

 

//client.cpp

  1. #include<iostream>  
  2. #include<fstream>  
  3. #include<WinSock2.h>  
  4. #include<Windows.h>  
  5. #include<tchar.h>  
  6. using namespace std;  
  7. #define BUF_TIMES 10  
  8. struct CompletionKey{SOCKET s;};  
  9. typedef struct io_operation_data  
  10. {  
  11.     WSAOVERLAPPED   overlapped;             //重叠结构  
  12.     WSABUF      wsaBuf;                  //发送接收缓冲区  
  13. }IO_OPERATION_DATA, *PIO_OPERATION_DATA;  
  14. SOCKET sClient;  
  15. //char (*data)[1024];  
  16. DWORD WINAPI ServiceThreadProc(PVOID pParam);  
  17. int main()  
  18. {  
  19.     HRESULT  hr=CoInitializeEx(NULL,COINIT_MULTITHREADED);  
  20.     if(FAILED(hr))  
  21.     {  
  22.         MessageBox(NULL,_T("Initialize COM failed!"),_T("error"),MB_OK);  
  23.         //cout<<"Initialize COM failed!"<<endl;  
  24.         //return false;  
  25.     }  
  26.     WORD wVersionRequest;  
  27.     WSADATA wsaData;  
  28.     wVersionRequest=MAKEWORD(2,2);  
  29.     int nErrCode=WSAStartup(wVersionRequest,&wsaData);  
  30.     if(nErrCode!=0)  
  31.     {  
  32.         //cout<<" start up error!"<<endl;  
  33.         MessageBox(NULL,_T("start up error!"),_T("error"),MB_OK);  
  34.     }  
  35.     if(LOBYTE(wsaData.wVersion)!=2||HIBYTE(wsaData.wVersion)!=2)  
  36.     {  
  37.         //cout<<" lib is not 2.2!"<<endl;  
  38.         MessageBox(NULL,_T("lib is not 2.2!"),_T("error"),MB_OK);  
  39.         WSACleanup();  
  40.     }  
  41.     sClient=WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);//socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);  
  42.     if(INVALID_SOCKET==sClient)  
  43.     {  
  44.         MessageBox(NULL,_T("socket error!"),_T("error"),MB_OK);  
  45.     }  
  46.   
  47.     //获取系统默认的发送数据缓冲区大小  
  48.     unsigned int uiRcvBuf;  
  49.     int uiRcvBufLen = sizeof(uiRcvBuf);  
  50.     nErrCode= getsockopt(sClient, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, &uiRcvBufLen);  
  51.     if (SOCKET_ERROR == nErrCode)  
  52.     {  
  53.         //cout<<"获取系统默认的发送数据缓冲区大小failed!"<<endl;  
  54.         MessageBox(NULL,_T("获取系统默认的发送数据缓冲区大小failed!"),_T("error"),MB_OK);  
  55.         //return false;  
  56.     }  
  57.     //设置系统发送数据缓冲区为默认值的BUF_TIMES倍  
  58.     uiRcvBuf *= BUF_TIMES;  
  59.     nErrCode = setsockopt(sClient, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, uiRcvBufLen);  
  60.     if (SOCKET_ERROR == nErrCode)  
  61.     {  
  62.         //cout<<"修改系统发送数据缓冲区失败！"<<endl;  
  63.         MessageBox(NULL,_T("修改系统发送数据缓冲区失败！"),_T("error"),MB_OK);  
  64.     }  
  65.   
  66.     //检查设置系统发送数据缓冲区是否成功  
  67.     unsigned int uiNewRcvBuf;  
  68.     nErrCode=getsockopt(sClient, SOL_SOCKET, SO_SNDBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen);  
  69.     if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf)  
  70.     {  
  71. //      cout<<"修改系统发送数据缓冲区失败！"<<endl;  
  72.         MessageBox(NULL,_T("修改系统发送数据缓冲区失败！"),_T("error"),MB_OK);  
  73.     }  
  74.     HANDLE CompPort=CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);  
  75.     if (CompPort == NULL)  
  76.     {  
  77.         MessageBox(NULL,_T("创建完成端口失败!"),_T("error"),MB_OK);  
  78.         //WSACleanup();  
  79.         //return ;  
  80.     }  
  81.     CompletionKey iCompletionKey;  
  82.     iCompletionKey.s=sClient;  
  83.     if (CreateIoCompletionPort((HANDLE)sClient,CompPort,(DWORD)&iCompletionKey,0) == NULL)  
  84.     {  
  85.         //出错处理。。  
  86.         MessageBox(NULL,_T("关联完成端口失败!"),_T("error"),MB_OK);  
  87.     }  
  88.     //addrHost    
  89.     SOCKADDR_IN addrHost;  
  90.     addrHost.sin_family=AF_INET;  
  91.     addrHost.sin_port=htons(8800);  
  92.     addrHost.sin_addr.S_un.S_addr=inet_addr("192.168.0.137");  
  93.   
  94.     int retVal=connect(sClient,(sockaddr*)&addrHost,sizeof(sockaddr));  
  95.     if(retVal==SOCKET_ERROR)  
  96.     {  
  97.         MessageBox(NULL,_T("connect error!"),_T("error"),MB_OK);  
  98.         //return false;  
  99.     }  
  100.     cout<<"connect success"<<endl;  
  101.   
  102.     HANDLE hThread=CreateThread(NULL,0,ServiceThreadProc,NULL,0,NULL);  
  103.       
  104.     DWORD           dwIoSize=-1;        //传输字节数  
  105.     LPOVERLAPPED    lpOverlapped=NULL;  //重叠结构指针  
  106.     CompletionKey*  pCompletionKey=NULL;  
  107.     PIO_OPERATION_DATA pIO=NULL;  
  108.     int count=0;  
  109.     ofstream fos;  
  110.     fos.open("c.txt");  
  111.   
  112.     while(1)  
  113.     {  
  114.         BOOL bIORet = GetQueuedCompletionStatus(CompPort,  
  115.                                                 &dwIoSize,  
  116.                                                 (LPDWORD)&pCompletionKey,  
  117.                                                 &lpOverlapped,  
  118.                                                 INFINITE);  
  119.         //失败的操作完成  
  120.         if (FALSE == bIORet && NULL != pCompletionKey)  
  121.         {     
  122.             //客户端断开  
  123.         }  
  124.         //成功的操作完成  
  125.         if(bIORet && lpOverlapped && pCompletionKey)  
  126.         {  
  127.             cout<<"count: "<<count+1<<"  "  
  128.                 <<"number: "<<dwIoSize<<endl;  
  129.             pIO = CONTAINING_RECORD(lpOverlapped,IO_OPERATION_DATA,overlapped);  
  130.             fos.write(pIO->wsaBuf.buf,10240*5);  
  131.             fos<<endl;  
  132.             if(count==99)  
  133.                 break;  
  134.             count++;  
  135.         }  
  136.   
  137.     }  
  138.       
  139.     WaitForSingleObject(hThread,INFINITE);  
  140.     cout<<"main end: "<<count+1<<endl;  
  141.     fos.close();  
  142.     Sleep(5000);  
  143.     CoUninitialize();  
  144.     WSACleanup();  
  145.     return 0;  
  146. }  
  147. DWORD WINAPI ServiceThreadProc(PVOID pParam)  
  148. {  
  149.     char (*a)[10240*5]=new char[100][10240*5];  
  150.     for(int i=0;i<100;i++)  
  151.     {  
  152.         if(i%3==0)  
  153.             memset(a[i],'a',10240*5);  
  154.         else if(i%3==1)  
  155.             memset(a[i],'b',10240*5);  
  156.         else if(i%3==2)  
  157.             memset(a[i],'c',10240*5);  
  158.     }  
  159.     DWORD   flags = 0;          //标志  
  160.     DWORD   sendBytes =0;       //发送字节数  
  161.     int count=0;  
  162.     while(count<100)  
  163.     {  
  164.         PIO_OPERATION_DATA pIO = new IO_OPERATION_DATA;   
  165.         ZeroMemory(pIO,sizeof(IO_OPERATION_DATA));  
  166.         pIO->wsaBuf.buf=a[count];  
  167.         pIO->wsaBuf.len=10240*5;  
  168.           
  169.         //Sleep(30);  
  170.         if(WSASend(sClient,&(pIO->wsaBuf),1,&sendBytes,flags,&(pIO->overlapped),NULL)== SOCKET_ERROR)  
  171.         {  
  172.             if(ERROR_IO_PENDING != WSAGetLastError())//发起重叠操作失败  
  173.             {  
  174.                 cout<<"send failed"<<endl;  
  175.             }  
  176.         }  
  177.         count++;  
  178.     }  
  179.       
  180.     cout<<"thread func:  "<<count<<endl;  
  181.     Sleep(10000);  
  182.       
  183.     return 0;  
  184. }  

 

//server.cpp

 

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<vector>  
  3. #include<fstream>  
  4. #include<WinSock2.h>  
  5. #include<Windows.h>  
  6. #include<tchar.h>  
  7. using namespace std;  
  8. #define BUF_TIMES 10  
  9. struct CompletionKey{SOCKET s;};  
  10. typedef struct io_operation_data  
  11. {  
  12.     WSAOVERLAPPED   overlapped;             //重叠结构  
  13.     WSABUF      wsaBuf;                  //发送接收缓冲区  
  14. }IO_OPERATION_DATA, *PIO_OPERATION_DATA;  
  15. int main()  
  16. {  
  17.     HRESULT  hr=CoInitializeEx(NULL,COINIT_MULTITHREADED);  
  18.     if(FAILED(hr))  
  19.     {  
  20.         MessageBox(NULL,_T("Initialize COM failed!"),_T("error"),MB_OK);  
  21.         //cout<<"Initialize COM failed!"<<endl;  
  22.         //return false;  
  23.     }  
  24.     WORD wVersionRequest;  
  25.     WSADATA wsaData;  
  26.     wVersionRequest=MAKEWORD(2,2);  
  27.     int nErrCode=WSAStartup(wVersionRequest,&wsaData);  
  28.     if(nErrCode!=0)  
  29.     {  
  30.         //cout<<" start up error!"<<endl;  
  31.         MessageBox(NULL,_T("start up error!"),_T("error"),MB_OK);  
  32.     }  
  33.     if(LOBYTE(wsaData.wVersion)!=2||HIBYTE(wsaData.wVersion)!=2)  
  34.     {  
  35.         //cout<<" lib is not 2.2!"<<endl;  
  36.         MessageBox(NULL,_T("lib is not 2.2!"),_T("error"),MB_OK);  
  37.         WSACleanup();  
  38.     }  
  39.     SOCKET sListen=WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);//socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);  
  40.     if(INVALID_SOCKET==sListen)  
  41.     {  
  42.         MessageBox(NULL,_T("socket error!"),_T("error"),MB_OK);  
  43.     }  
  44.       
  45.     //获取系统默认的发送数据缓冲区大小  
  46.     unsigned int uiRcvBuf;  
  47.     int uiRcvBufLen = sizeof(uiRcvBuf);  
  48.     nErrCode= getsockopt(sListen, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, &uiRcvBufLen);  
  49.     if (SOCKET_ERROR == nErrCode)  
  50.     {  
  51.         //cout<<"获取系统默认的发送数据缓冲区大小failed!"<<endl;  
  52.         MessageBox(NULL,_T("获取系统默认的发送数据缓冲区大小failed!"),_T("error"),MB_OK);  
  53.         //return false;  
  54.     }  
  55.     //设置系统发送数据缓冲区为默认值的BUF_TIMES倍  
  56.     uiRcvBuf *= BUF_TIMES;  
  57.     nErrCode = setsockopt(sListen, SOL_SOCKET, SO_SNDBUF,(char*)&uiRcvBuf, uiRcvBufLen);  
  58.     if (SOCKET_ERROR == nErrCode)  
  59.     {  
  60.         //cout<<"修改系统发送数据缓冲区失败！"<<endl;  
  61.         MessageBox(NULL,_T("修改系统发送数据缓冲区失败！"),_T("error"),MB_OK);  
  62.     }  
  63.     //检查设置系统发送数据缓冲区是否成功  
  64.     unsigned int uiNewRcvBuf;  
  65.     nErrCode=getsockopt(sListen, SOL_SOCKET, SO_SNDBUF,(char*)&uiNewRcvBuf, &uiRcvBufLen);  
  66.     if (SOCKET_ERROR == nErrCode || uiNewRcvBuf != uiRcvBuf)  
  67.     {  
  68. //      cout<<"修改系统发送数据缓冲区失败！"<<endl;  
  69.         MessageBox(NULL,_T("修改系统发送数据缓冲区失败！"),_T("error"),MB_OK);  
  70.     }  
  71.     //cout<<uiNewRcvBuf<<endl;  
  72.     HANDLE CompPort=CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);  
  73.     if (CompPort == NULL)  
  74.     {  
  75.         MessageBox(NULL,_T("创建完成端口失败!"),_T("error"),MB_OK);  
  76.         //WSACleanup();  
  77.         //return ;  
  78.     }  
  79.     SOCKADDR_IN addrHost;  
  80.     addrHost.sin_family=AF_INET;  
  81.     addrHost.sin_port=htons(8800);  
  82.     addrHost.sin_addr.S_un.S_addr=INADDR_ANY;  
  83.     int retVal=bind(sListen,(LPSOCKADDR)&addrHost, sizeof(SOCKADDR_IN));  
  84.     if(SOCKET_ERROR==retVal)  
  85.     {  
  86.         //cout<<"bind error!"<<endl;  
  87.         MessageBox(NULL,_T("bind error!"),_T("error"),MB_OK);  
  88.         //closesocket(this->m_sListen);  
  89.         //return false;  
  90.     }  
  91.     retVal=listen(sListen,5);  
  92.     if(SOCKET_ERROR==retVal)  
  93.     {  
  94.         MessageBox(NULL,_T("listen error!"),_T("error"),MB_OK);  
  95.           
  96.     }  
  97.     sockaddr_in addrClient;  
  98.     int addrLen=sizeof(sockaddr_in);  
  99.     SOCKET sClient=accept(sListen,(sockaddr*)&addrClient,&addrLen);  
  100.       
  101.     cout<<"come in"<<endl;  
  102.     CompletionKey iCompletionKey;  
  103.     iCompletionKey.s=sClient;  
  104.     //关联完成端口  
  105.     if (CreateIoCompletionPort((HANDLE)sClient,CompPort,(DWORD)(&iCompletionKey),0) == NULL)  
  106.     {  
  107.         //出错处理。。  
  108.         MessageBox(NULL,_T("关联完成端口失败!"),_T("error"),MB_OK);  
  109.     }  
  110.     DWORD           dwIoSize=-1;        //传输字节数  
  111.     LPOVERLAPPED    lpOverlapped=NULL;  //重叠结构指针  
  112.     CompletionKey*  pCompletionKey=NULL;  
  113.     DWORD   flags = 0;      //标志  
  114.     DWORD   recvBytes =0;   //接收字节数  
  115.     PIO_OPERATION_DATA pIO=NULL;  
  116.     int count=0;  
  117.     pIO=new IO_OPERATION_DATA;  
  118.     ZeroMemory(pIO, sizeof(IO_OPERATION_DATA));  
  119.     pIO->wsaBuf.buf=new char[10240*5];  
  120.     pIO->wsaBuf.len=10240*5;  
  121.     if (WSARecv(sClient,&(pIO->wsaBuf),1,&recvBytes,&flags,&(pIO->overlapped),NULL) == SOCKET_ERROR)  
  122.     {  
  123.         if(ERROR_IO_PENDING != WSAGetLastError())  
  124.         {  
  125.             cout<<"recv failed"<<endl;  
  126.         }  
  127.     }  
  128.     vector<IO_OPERATION_DATA*> vecCache;  
  129.     ofstream fos;  
  130.     fos.open("s.txt");  
  131.     while(1)  
  132.     {  
  133.         BOOL bIORet = GetQueuedCompletionStatus(CompPort,  
  134.                             &dwIoSize,  
  135.                             (LPDWORD)&pCompletionKey,  
  136.                             &lpOverlapped,  
  137.                             INFINITE);  
  138.         //失败的操作完成  
  139.         if (FALSE == bIORet && NULL != pCompletionKey)  
  140.         {     
  141.             //客户端断开   
  142.         }  
  143.         //成功的操作完成  
  144.         if(bIORet && lpOverlapped && pCompletionKey)  
  145.         {  
  146.             pIO = CONTAINING_RECORD(lpOverlapped,IO_OPERATION_DATA,overlapped);  
  147.             if(dwIoSize<pIO->wsaBuf.len)  
  148.             {  
  149.                 vecCache.push_back(pIO);  
  150.                 int size=pIO->wsaBuf.len;  
  151.                 pIO->wsaBuf.len=dwIoSize;  
  152.                 pIO=new IO_OPERATION_DATA;  
  153.                 ZeroMemory(pIO, sizeof(IO_OPERATION_DATA));  
  154.                 pIO->wsaBuf.buf=new char[size-dwIoSize];  
  155.                 pIO->wsaBuf.len=size-dwIoSize;  
  156.                 if (WSARecv(sClient,&(pIO->wsaBuf),1,&recvBytes,&flags,&(pIO->overlapped),NULL) == SOCKET_ERROR)  
  157.                 {  
  158.                     if(ERROR_IO_PENDING != WSAGetLastError())  
  159.                     {             
  160.                         cout<<"recv failed"<<endl;  
  161.                     }  
  162.                 }  
  163.             }  
  164.             else  
  165.             {  
  166.                 if(vecCache.size()!=0)  
  167.                 {  
  168.                     char*p=new char[10240*5];  
  169.                     int size=0;  
  170.                     for(vector<IO_OPERATION_DATA*>::iterator it=vecCache.begin();  
  171.                         it!=vecCache.end();it++)  
  172.                     {  
  173.                         memcpy(p+size,(*it)->wsaBuf.buf,(*it)->wsaBuf.len);  
  174.                         size+=(*it)->wsaBuf.len;  
  175.                         //清理资源  
  176.                         delete []((*it)->wsaBuf.buf);  
  177.                         delete (*it);  
  178.                     }  
  179.                     memcpy(p+size,pIO->wsaBuf.buf,pIO->wsaBuf.len);  
  180.                     count++;  
  181.                     fos.write(p,10240*5);  
  182.                     fos<<endl;  
  183.                     vecCache.clear();  
  184.                     cout<<"count: "<<count<<endl;  
  185.                     //清理资源  
  186.                     delete [](pIO->wsaBuf.buf);  
  187.                     delete pIO;  
  188.                     delete []p;  
  189.                 }  
  190.                 else  
  191.                 {  
  192.                     count++;  
  193.                     fos.write(pIO->wsaBuf.buf,10240*5);  
  194.                     fos<<endl;  
  195.                     cout<<"count: "<<count  
  196.                         <<"  number: "<<dwIoSize<<endl;  
  197.                     //清理资源  
  198.                     delete [](pIO->wsaBuf.buf);  
  199.                     delete pIO;  
  200.                 }  
  201.                     pIO=new IO_OPERATION_DATA;  
  202.                     ZeroMemory(pIO, sizeof(IO_OPERATION_DATA));  
  203.                     pIO->wsaBuf.buf=new char[10240*5];  
  204.                     pIO->wsaBuf.len=10240*5;  
  205.                     if (WSARecv(sClient,&(pIO->wsaBuf),1,&recvBytes,&flags,&(pIO->overlapped),NULL) == SOCKET_ERROR)  
  206.                     {  
  207.                         if(ERROR_IO_PENDING != WSAGetLastError())  
  208.                         {             
  209.                             cout<<"recv failed"<<endl;  
  210.                         }  
  211.                     }  
  212.                   
  213.             }  
  214.             if(count==100)  
  215.                 break;  
  216.         }  
  217.     }  
  218.       
  219.     cout<<"main end: "<<count<<endl;  
  220.     fos.close();  
  221.     Sleep(10000);  
  222.     CoUninitialize();  
  223.     WSACleanup();  
  224.     return 0;  
  225. }  
jiangqin115
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
IOCP 使用WSASend群发消息
04-28
http://download.csdn.net/my/uploads 稍加改动
IOCP WSASend()
machuanfei_c的专栏
01-09 1771
WSASend 函数： 在一个已连接的套接口上发送数据 简述 语法 int WSASend( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAO
IOCP投递多个WSARecv存在的问题
回头太难
07-16 1672
看完A simple IOCP Server/Client Class发现 IOCP投递多个WSARecv存在3个问题： 1. 多个pending recv，多个worker，数据包会乱序。 解决方法：可以通过给数据包加序号解决。但是不确定性能能提高多少，codeproject的作者对多worker的处理是只有一个pending recv 2.多个pending recv，多个work...
Send 和 WSASend
HappyJandun's 学习笔录
11-01 6896
WinSock 常用的API包括TCP协议使用的send、recv、WSASend和WSARecv，UDP协议使用的sendto、recvfrom、WSASendTo 和WSARecvFrom。           socket本身有一个send函数，这个函数的只能一次发送一个缓冲区，这对于在发送大量数据的时候或者数据包很多的时候就可能导致系统的低性能，主要原因在于调用太多次的send函数，
完成端口使用总结
fripy的专栏
09-06 308
完成端口的设置和处理，循环方式。 overlapped io重叠的使用，内存申请等问题。 完成端口的send和recv的缓冲区的重复利用和如何释放的问题。 keepalived，windows的调用和linux的调用方式（这两个系统都有这个机制），但是默认设置不一样，并且设置的api接口也不一样。自己也可以根据这个原理定制自己的心跳机制（用settimer或线程进行定时发送心跳）。 rec...
采用完成端口（IOCP）实现高性能网络服务器（Windows c++版）
本人研究ofd多年，独立研发了ofd阅读器、ofd轻阅读、ofd与pdf互转、ofd模板设计与生成、ofd拆分合并、ofd签章和验签等工具！
10-06 1013
前言 　TCP\IP已成为业界通讯标准。现在越来越多的程序需要联网。网络系统分为服务端和客户端，也就是c\s模式(client \ server)。client一般有一个或少数几个连接；server则需要处理大量连接。大部分情况下，只有服务端才特别考虑性能问题。本文主要介绍服务端处理方法，当然也可以用于客户端。 　 我也发表过c#版网络库。其实，我最早是从事c++开发，多年前就实现了对完成端口...
Socket向完成端口多次发送消息浅见
skyair624的专栏
07-18 6765
1.     同时发送多个WSARecv消息处理，多余的会有什么情况？使用代码测试，显示结果为全部返回错误997，表示都可以正常发出recv操作，且多个工作线程同时在检测此socket的多个recv消息，运行片刻立即关闭Client端，发现工作线程出现的异常，1个或2个工作线程中的closesocket函数调用失败，错误码为10038，因此要尽力避免对同一个socket向完成端口发送重复的同一
IOCP.rar_IOCP
09-21
3. **提交I/O请求**: 使用设备特定的API（如WSASend、WSARecv等）发起异步I/O操作，并指定IOCP。 4. **处理完成**: 当I/O操作完成后，系统会将完成信息放入IOCP队列中。 5. **获取完成**: 使用...
IOCP服务器模块.rar
04-05
4. 异步读写：通过WSASend和WSARecv发起异步读写操作，设置相应的完成状态，并传递到IOCP。 5. 处理完成队列：创建一组工作线程，循环从IOCP中获取完成的I/O事件，执行对应的回调函数进行数据处理。 四、性能优化与...
IOCP.rar_IOCP_VC++IOCP
09-20
3. 发起I/O操作：使用`TransmitFile`、`WSASend`、`WSARecv`等函数发起异步I/O请求。这些函数会立即返回，不会阻塞当前线程，而是将请求放入操作系统的I/O队列。 4. 获取I/O完成通知：在后台线程中，不断调用`...
IOCP_class.rar_IOCP
09-23
在IOCP模型下，数据的发送和接收通常通过`WSASend`和`WSARecv`函数来实现。这两个函数是非阻塞的，立即返回，并将I/O操作提交给系统。当数据发送或接收完成时，系统会将结果通知到IOCP。 **IOCP类的设计** 根据...
iocp_tcp服务端.rar
04-05
- 发送和接收数据：利用WSASend和WSARecv函数进行异步发送和接收，这些函数会在后台执行，完成后将结果放入IOCP的完成队列。 - 处理完成队列：服务器维护一组工作线程，它们不断从IOCP的完成队列中取出完成的I/O...
ICOP的一些结论 -- 仅是我的实践结论
li_jian_xing的专栏
09-13 1062
ICOP的一些结论 -- 仅是我的实践结论   来自：网络博客 本文主要表述ICOP使用中的一些结论 -- 但仅仅是我的实践结论，不一定正确，仅供大家参考。 TAG: 心得  IOCP     对同一个连接连续调用多次WSASend是安全的,不需要等到前一个WSASend的操作完成,数据将按调用WSASend的调用顺序发送(当
WSARecv()函数
东方猫的博客
11-26 4239
WSARecv()是从一个套接口接收数据的程序。主要用于在重叠模型中接收数据。 #include <winsock2.h> int WSAAPI WSARecv ( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPINT lpFlags, LPWSAOVERLAPPED l
Socket编程模型之重叠IO（Overlapped I/O）模型
cheqiane9431的博客
08-14 327
转载请注明来源：http://blog.csdn.net/caoshiying/article/details/52876090 一、原理 Winsock2的发布使得Socket I/O有了和文件I/O统一的接口。我们可以通过使用Win32文件操纵函数ReadFile和WriteFi...
WSRecv
行走
01-07 667
WSARecv()是从一个套接口接收数据的程序。主要用于在重叠模型中接收数据。 int WSARecv( SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRecvd, LPDWORD lpFlags, LPWSAOVERLAPPED lpOverlapped, LPWSA...
IOCP中在WSASend以及WSARecv的时候出现WSA_IO_PENDING情况的说明
weixin_30522183的博客
07-13 339
原文链接：http://www.xixis.net/doserver.net//read.php/2063.htm应该是windows网络编程第二版里面提到过。现在整理一下。 1：在IOCP中投递WSASend返回WSA_IO_PENDING的时候，表示异步投递已经成功，但是稍后发送才会完成。这其中涉及到了三个缓冲区。网卡缓冲区，TCP/IP层缓冲区，程序缓冲区。情况一：调用WSASend发送...
Windows套接字I/O模型（5） -- 完成端口模型
热门推荐
while(1) { smile(); }
12-15 9万+
一、写在前面 前面介绍了套接字I/O的同步模型、WSAAsyncSelect模型、WSAEventSelect模型，套接字I/O还剩下2个模型没有介绍：重叠模型，完成端口模型。 如果程序对性能和并发要求不高，可以使用前面介绍的WSAEventSelect模型；如果对性能和并发有要求，可以使用本文介绍的完成端口模型。 因为完成端口模型是基于重叠模型的，且在易用性、可伸缩性等方面都高于重叠模型...
IOCP模型与网络编程
jiangqin115的专栏
05-02 3240
一。前言：         在老师分配任务（“尝试利用IOCP模型写出服务端和客户端的代码”）给我时，脑子一片空白，并不知道什么是IOCP模型，会不会是像软件设计模式里面的工厂模式，装饰模式之类的那些呢？嘿嘿，不过好像是一个挺好玩的东西，挺好奇是什么东西来的，又是一个新知识啦~于是，开始去寻找一大堆的资料，为这个了解做准备，只是呢，有时还是想去找一本书去系统地学习一下，毕竟网络的资料还是有点零散
delphi iocp
最新发布
12-21
Delphi中的IOCP（Input/Output Completion Port）是一种高效的异步I/O模型，它通过在Windows平台上使用完成端口来提高输入输出的性能。IOCP使用了事件通知机制，支持并发的读写操作，能够在I/O操作完成后立刻通知应用程序，并且能够同时处理多个I/O请求，极大地提高了系统的性能和并发性能。 在Delphi中，我们可以利用IOCP来开发高性能的网络服务器程序，通过异步I/O操作来处理大量的客户端请求。借助IOCP，我们可以轻松地实现高并发的网络通信，提供更快速和稳定的服务，也可以有效地节约系统资源和提高系统的吞吐量。 使用Delphi开发基于IOCP的网络服务器，可以通过内置的TIOHandler组件来实现异步I/O操作，并且通过事件驱动的方式来处理I/O完成通知。借助Delphi强大的组件和工具，我们可以很方便地实现IOCP的功能，同时也可以利用Delphi丰富的第三方组件库来扩展功能，提高开发效率。 总之，Delphi中的IOCP提供了一种高效的异步I/O模型，可以帮助我们实现高性能的网络服务器应用。通过合理地利用IOCP，在Delphi中我们可以开发出性能优异、稳定可靠的网络服务应用，满足客户端的高并发请求。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值