重叠IO的一点问题

待续_1006 2017-06-06 09:41:13


问题1 如果WSAWaitForMultipleEvents最多只能等到64个事件,作为服务器而言只能同时连接64的客户端,不现实啊?



问题2 完成端口中开启线程的数量是处理器的2倍
按这个逻辑开启一万个线程要五千个处理器?什么逻辑?现实吗?
...全文
715 7 打赏 收藏 转发到动态 举报
写回复
用AI写文章
7 条回复
切换为时间正序
请发表友善的回复…
发表回复
smwhotjay 2017-10-12
  • 打赏
  • 举报
回复
来个例子
#include "stdafx.h"

#include <iostream>
#include <tchar.h>
#include <WINSOCK2.H>
#include <stdio.h>
#pragma comment(lib, "ws2_32.lib")

#define MSGSIZE 1024
#define PORT 10000


typedef struct
{
 WSAOVERLAPPED overlap;  
 WSABUF        Buffer;
 char		   szMessage[MSGSIZE];//
 DWORD         NumberOfBytesRecvd;
 DWORD         Flags; 
 SOCKET        sClient;
}PER_IO_OPERATION_DATA, *LPPER_IO_OPERATION_DATA;

void CALLBACK CompletionROUTINE(DWORD dwError,
                                DWORD cbTransferred,
                                LPWSAOVERLAPPED lpOverlapped,
                                DWORD dwFlags)
{
  LPPER_IO_OPERATION_DATA lpPerIOData = (LPPER_IO_OPERATION_DATA)lpOverlapped;
  SOCKET sock=lpPerIOData->sClient;
  if (dwError != 0 || cbTransferred == 0)
 {
    // Connection was closed by client
    closesocket(lpPerIOData->sClient);
  	printf("一个客户退出 socket id:%d\r\n",lpPerIOData->sClient);
   //释放客户对应的结构内存
	delete lpPerIOData;
	lpPerIOData=NULL;
 }
  else
  {

	  printf("recv sock:%d size:%d\n",sock,cbTransferred);
	 //在这里处理接收的数据,然后发送...并重置这个客户socket异步接收操作..

    //lpPerIOData->szMessage[cbTransferred] = '\0';
    //send(lpPerIOData->sClient, lpPerIOData->szMessage, cbTransferred, 0);
    
    // Launch another asynchronous operation
    memset(&lpPerIOData->overlap, 0, sizeof(WSAOVERLAPPED));
    lpPerIOData->Buffer.len = MSGSIZE;
    lpPerIOData->Buffer.buf = lpPerIOData->szMessage;    

    WSARecv(lpPerIOData->sClient,
      &lpPerIOData->Buffer,
      1,
      &lpPerIOData->NumberOfBytesRecvd,
      &lpPerIOData->Flags,
      &lpPerIOData->overlap,
      CompletionROUTINE);
  }
}

void GetError(DWORD error)	//返回错误信息
{

	switch(error)
	{
	case WSANOTINITIALISED:
		printf("初始化错误\r\n");
		break;
	case WSAENOTCONN:
			printf("对方没有启动\r\n");
		break;
	case WSAEWOULDBLOCK :
		printf("对方已经关闭\r\n");
		break;
	case WSAECONNREFUSED:
		printf("对方没打开端口\r\n");
		break;
	case WSAENOTSOCK:
		printf("在一个非套接字上尝试了一个操作\r\n");
		break;
	case WSAEADDRINUSE:
		printf("特定的地址已在使用中\r\n");
		break;
	case WSAECONNRESET:
		printf("与主机的连接被关闭\r\n");
		break;
	default:
		printf("一般错误,连接出现异常断开\r\n");	
	}

}




int main()
{


  WSADATA     wsaData;
  SOCKET      sListen;
  SOCKADDR_IN local, client;

  int         iaddrSize = sizeof(SOCKADDR_IN);

   // Initialize Windows Socket library
   int ret= WSAStartup(0x0202, &wsaData);
	if(ret!=0) 
	{
		printf("socket WSAStartup Error!\r\n");	
		return 1;
	}else printf("socket WSAStartup OK!\r\n");	
   // Create listening socket
   sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

 
   local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
   local.sin_family = AF_INET;
   local.sin_port = htons(PORT);
 	//绑定一个套接字到本机的地址
   ret= bind(sListen, (struct sockaddr *)&local, sizeof(SOCKADDR_IN));
	if(ret == SOCKET_ERROR)
	{	//绑定错误
		printf("Binding Error\r\n");
		return FALSE;
	}
     // Listen
    ret=  listen(sListen, 3);
	if(ret==SOCKET_ERROR)
	{
		printf("listen失败 错误原因:",ret=WSAGetLastError());
		GetError(ret);
		return false ;
	}
	printf("listen OK!\r\nWaiting Client Connect\n");	


  while (TRUE)
  {
    // Accept a connection
	 LPPER_IO_OPERATION_DATA lpPerIOData = NULL;
	SOCKET g_sNewClientConnection;
    g_sNewClientConnection = accept(sListen, (struct sockaddr *)&client, &iaddrSize);

    // Launch an asynchronous operation for new arrived connection

		lpPerIOData=new PER_IO_OPERATION_DATA();

      lpPerIOData->Buffer.len = MSGSIZE;
      lpPerIOData->Buffer.buf = lpPerIOData->szMessage;
      lpPerIOData->sClient = g_sNewClientConnection;
      
     ret= WSARecv(lpPerIOData->sClient,//客户socket
        &lpPerIOData->Buffer,  //存放接收数据的
        1, //dwBufferCount  [in] Number of WSABUF structures in the lpBuffers array. 
        &lpPerIOData->NumberOfBytesRecvd,//存放接收数据的字节数
        &lpPerIOData->Flags,
        &lpPerIOData->overlap,
        CompletionROUTINE);
	//如果接收的数据超过MSGSIZE 系统就会多次调用CompletionROUTINE,直到接收完..
	
    printf("Accepted client:%s:%d\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));


  }
}


smwhotjay 2017-10-12
  • 打赏
  • 举报
回复
1. 重叠io 有2种方式。一种是event事件来触发,一种是CompletionROUTINE 完成例程。 我喜欢完成例程,一个回调函数接收所有事件。 WSARecv 最后一个参数就是传入完成例程 ret= WSARecv(lpPerIOData->Client,//客户socket &lpPerIOData->Buffer, //存放接收数据的buffer 1, //dwBufferCount [in] Number of WSABUF structures in the lpBuffers array. &lpPerIOData->NumberOfBytesRecvd,//存放接收数据的字节数 &lpPerIOData->Flags, &lpPerIOData->overlap, CompletionROUTINE); 2.完成端口中开启线程的数量是处理器的2倍 双核就开4个工作线程啊!! 因为单核开一个线程等于浪费啊。
仍在发呆的~ 2017-10-12
  • 打赏
  • 举报
回复
楼主理解有问题, 问题1:64最大值是因为wait函数的限制, 并不是重叠io的问题, 如果想等大于64的客户端,可以调用多次wait 问题2:你说的一万多什么意思不太懂, 一个wait就可以处理64个客户端, 如果在一个线程调用100次wait就可以处理6400个客户端,当然多个wait是否在同一线程中还是多个线程中,你自己定义
worldy 2017-06-06
  • 打赏
  • 举报
回复
一般完成端口,使用特殊的同步对象,使用GetQueuedCompletionStatus函数进行同步 问题2:lz的理解有问题 完成端口相当于创建一个线程池,线程池的线程为所有的链接公用,线程池线程的数量按CPU数的2倍是个经验数据,你也可以是3倍 比如你的CUP是8核,则推荐你创建16线程,16个线程负责处理10000个用户请求
赵4老师 2017-06-06
  • 打赏
  • 举报
回复
《Windows核心编程》
worldy 2017-06-06
  • 打赏
  • 举报
回复
引用 3 楼 shiyanbo_1006 的回复:
[quote=引用 2 楼 worldy 的回复:] 一般完成端口,使用特殊的同步对象,使用GetQueuedCompletionStatus函数进行同步 问题2:lz的理解有问题 完成端口相当于创建一个线程池,线程池的线程为所有的链接公用,线程池线程的数量按CPU数的2倍是个经验数据,你也可以是3倍 比如你的CUP是8核,则推荐你创建16线程,16个线程负责处理10000个用户请求
问题1我问的是关于重叠IO的问题啊。。。。[/quote] 没有回答你问题1,一般都是用完成端口,重叠IO忘记了,等待别人回复吧
待续_1006 2017-06-06
  • 打赏
  • 举报
回复
引用 2 楼 worldy 的回复:
一般完成端口,使用特殊的同步对象,使用GetQueuedCompletionStatus函数进行同步

问题2:lz的理解有问题
完成端口相当于创建一个线程池,线程池的线程为所有的链接公用,线程池线程的数量按CPU数的2倍是个经验数据,你也可以是3倍
比如你的CUP是8核,则推荐你创建16线程,16个线程负责处理10000个用户请求



问题1我问的是关于重叠IO的问题啊。

18,356

社区成员

发帖
与我相关
我的任务
社区描述
VC/MFC 网络编程
c++c语言开发语言 技术论坛(原bbs)
社区管理员
  • 网络编程
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧