windows select

最新推荐文章于 2023-05-08 20:10:54 发布
最新推荐文章于 2023-05-08 20:10:54 发布
阅读量641 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cschengvdn/article/details/50165303
版权

第一步 :双线程


// SelectServer.cpp


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


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


DWORD WINAPI SelectProc(LPVOID lpParameter)
{
if (NULL == lpParameter)
{
printf("invalid thread param!\n");
return -1;
}


SOCKET sAccept = *(SOCKET*)(lpParameter);
char szRecv[4096] = {0};

fd_set fdRead;
fd_set fdWrite;
fd_set fdExcept;
timeval time;
time.tv_sec = INFINITE;
time.tv_usec = 0;


for ( ; ;)
{
FD_ZERO(&fdRead);

FD_SET(sAccept, &fdRead);   // 1.这个要放在select 前，每次都要处理的


int nRet = select(0, &fdRead, NULL, NULL, &time/*NULL*/);
if (SOCKET_ERROR == nRet)
{
DWORD dwLastErr = WSAGetLastError();
printf("select socket error! err: %u\n", dwLastErr);
break;
}




if( FD_ISSET( sAccept, &fdRead ) )
//if (fdRead.fd_array[0] == sAccept)
{
printf("select a read socket\n");
nRet = recv(sAccept, szRecv, 4096, 0);
if (SOCKET_ERROR != nRet)
{
printf("recv data: %s\n", szRecv);
}

nRet = send(sAccept, szRecv, strlen(szRecv), 0);
if (SOCKET_ERROR == nRet)
{
printf("send data error\n");
break;
}

printf("send data: %s\n", szRecv);


FD_CLR( sAccept , &fdRead );
closesocket(sAccept);
sAccept = INVALID_SOCKET;
}






if (INVALID_SOCKET == sAccept)
{
printf("I'm INVALID_SOCKET ,I will return\n");
return 0;
}

}

if (INVALID_SOCKET != sAccept)
{
closesocket(sAccept);
sAccept = INVALID_SOCKET;
}

printf("thread exit\n");

return 0;
}


int main()
{
DWORD dwVersion = 0;
WSADATA wsaData;
DWORD dwErr = 0;
int kk =0;
dwErr = WSAStartup(MAKEWORD(0x2, 0x2), &wsaData);
if (0 != dwErr)
{
printf("winsock init error!\n");
return -1;
}


if (0x2 != LOBYTE(wsaData.wVersion) ||
0x2 != HIBYTE(wsaData.wVersion))
{
// couldn't find a usable WinSock DLL.
printf("request winsock version error!\n");
WSACleanup();
return -1;
}


//SOCKET sAccept = INVALID_SOCKET;


SOCKET sAccept[512] = {INVALID_SOCKET}; //这个要注意，如果只用一个会覆盖，因为可能多个连接


SOCKET sListen = socket(AF_INET, SOCK_STREAM, 0);
if (INVALID_SOCKET == sListen)
{
printf("create a socket error!\n");
WSACleanup();
return -1;
}


sockaddr_in servAddr;
ZeroMemory(&servAddr, sizeof(servAddr));
servAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
servAddr.sin_family = AF_INET;
servAddr.sin_port = htons(80);


sockaddr_in clientAddr;
ZeroMemory(&clientAddr, sizeof(clientAddr));
int nLen = sizeof(clientAddr);


DWORD dwThreadID = 0;
HANDLE hThread = NULL;

if (SOCKET_ERROR == bind(sListen, (struct sockaddr*)&servAddr, sizeof(servAddr)))
{
printf("bind socket error!\n");
dwErr = WSAGetLastError();
goto _QUIT;
}


if (SOCKET_ERROR == listen(sListen, SOMAXCONN))
{
printf("listen socket error!\n");
dwErr = WSAGetLastError();
goto _QUIT;
}


printf("listen......\n");




while (1)
{
sAccept[kk] = accept(sListen, (sockaddr *)&clientAddr, &nLen);
if (INVALID_SOCKET == sAccept[kk])
{
printf("accept a socket error!\n");
dwErr = WSAGetLastError();
break;
}

printf("accept a socket\n");
hThread = CreateThread(NULL, 0, SelectProc, &sAccept[kk], 0, &dwThreadID);
if (NULL == hThread)
{
printf("create thread error!\n");
dwErr = -1;
goto _QUIT;
}
kk++;
}



_QUIT:


if (INVALID_SOCKET != sListen)
{
closesocket(sListen);
sListen = INVALID_SOCKET;
}


WSACleanup();
return dwErr;
}


这样，并不是完全的异步方式


异步单线程


#include <stdio.h>
#include <string.h>
#include <WINSOCK2.H>

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

#define STR_SERVER_IP           "127.0.0.1"
#define INT_SERVER_PORT         80
#define INT_DATABUFFER_SIZE     2560



bool reachDelayTime(SYSTEMTIME nowTime,SYSTEMTIME startTime)
{
	//是先算后面的吗
	if (nowTime.wYear>startTime.wYear ||
		nowTime.wMonth > startTime.wMonth ||
		nowTime.wDay>startTime.wDay||
		nowTime.wHour> startTime.wHour||
		nowTime.wMinute>startTime.wMinute||
		nowTime.wSecond>=(startTime.wSecond+2))   //>=2s 实际为1s以上
	{
		return true;
	}
	return false;
}


int main(int argc, char* argv[])
{


	SYSTEMTIME startT,nowT;

    GetLocalTime(&startT);

	
/*
	printf("now1 %d %d \n",startT.wSecond,startT.wMilliseconds );
	Sleep(1);
	 GetLocalTime(&nowT);
	 nowT.wMonth = startT.wMonth+0;
	printf("now2 %d %d \n",nowT.wSecond,nowT.wMilliseconds );


	printf("reachDelayTime=%d \n",reachDelayTime(nowT,startT) );
	//printf("now2 %d \n",time2 );

	return 1;
*/

    WORD dwVersion = MAKEWORD(2,2);
    WSAData wsaData;
    WSAStartup(WINSOCK_VERSION,&wsaData);

    SOCKET sockServer = socket(AF_INET, SOCK_STREAM, 0);
    if (INVALID_SOCKET == sockServer) {
        printf("Failed to create socket!\r\n");
        WSACleanup();
        return -1;
    }
	
    sockaddr_in addrServer;
    memset(&addrServer,0,sizeof(sockaddr_in));
    addrServer.sin_family = AF_INET;
    addrServer.sin_port = htons(INT_SERVER_PORT);
    addrServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
    //addrServer.sin_addr.s_addr = htonl(INADDR_ANY);

    int iResult;

    bool bReuseAddr = true;
    iResult=setsockopt(sockServer,SOL_SOCKET,SO_REUSEADDR,(char *)&bReuseAddr,sizeof(bReuseAddr));
    if(SOCKET_ERROR == iResult) {
        printf("Failed to set resueaddr socket!\r\n");
        WSACleanup();
        return -1;
    }
	
    
    //unsigned   long cmd = 1;
   // iResult= ioctlsocket(sockServer,FIONBIO,&cmd); 

    iResult = bind(sockServer,(sockaddr *)&addrServer,sizeof(addrServer));
    if (SOCKET_ERROR == iResult) {
        printf("Failed to bind address!\r\n");
        WSACleanup();
        return -1;
    }

    if (0 != listen(sockServer,5)) {
        printf("Failed to listen client!\r\n");
        WSACleanup();
        return -1;
    }

    UINT i = 0;
    SOCKET sockAccept;
    sockaddr_in addrAccept;
    int iAcceptLen = sizeof(addrAccept);
    char szDataBuff[INT_DATABUFFER_SIZE];
    int iRecvSize;
    
	int t1 = INVALID_SOCKET;

	SOCKET sAccept[512] = {INVALID_SOCKET}; //这个要注意，如果只用一个会覆盖，因为可能多个连接

	memset(sAccept,INVALID_SOCKET,512*sizeof(SOCKET));

    sockaddr_in addrTemp;
    int iTempLen;

    fd_set fdRead;


    
    timeval tm;
    tm.tv_sec = 0;
    tm.tv_usec = 1000;
    
    printf("Start server...\r\n");

	int iTemp=0;
    while(1) 
	{
		FD_ZERO(&fdRead);
		FD_SET(sockServer, &fdRead);


		//printf("INVALID_SOCKET %d \n",INVALID_SOCKET);
		for( iTemp=0;iTemp<512;iTemp++)
		{
			if (sAccept[iTemp] != INVALID_SOCKET )
			{
				FD_SET(sAccept[iTemp], &fdRead);
			}
		}


        iResult = select(0, &fdRead, NULL, NULL,&tm/*NULL*/); //&tm
        if (0 <= iResult) 
		{
			printf("iResult=%d \n", iResult);


			if (FD_ISSET(sockServer, &fdRead)) 
			{
				memset(&addrAccept,0,sizeof(addrTemp));
				sockAccept = accept(sockServer, (sockaddr *)&addrAccept, &iAcceptLen);
				if (INVALID_SOCKET != sockAccept) 
				{
					sAccept[iTemp] == INVALID_SOCKET; // 马上还要重新设置
					
					printf("%s:%d has connected server!\r\n", inet_ntoa(addrAccept.sin_addr),
						ntohs(addrAccept.sin_port));
                 }

				for( iTemp=0;iTemp<512;iTemp++)
				{
					if (sAccept[iTemp] == INVALID_SOCKET )
					{
						sAccept[iTemp] = sockAccept;
						break;
					}
				}
			}

		
            for(iTemp=0;iTemp<512;iTemp++) 
			{
			  if(sAccept[iTemp]!= INVALID_SOCKET)
			  {
                if (FD_ISSET(sAccept[iTemp], &fdRead)) 
				{
  
					{ //非服务器,接收数据(因为fd是读数据集)
                        memset(szDataBuff, 0, INT_DATABUFFER_SIZE);
                        iRecvSize = recv(sAccept[iTemp], szDataBuff, INT_DATABUFFER_SIZE, 0);

                        memset(&addrTemp, 0, sizeof(addrTemp));
                        iTempLen = sizeof(addrTemp);
                        getpeername(sAccept[iTemp], (sockaddr *)&addrTemp, &iTempLen);

                        // an error occurs
                        if (SOCKET_ERROR == iRecvSize) 
						{
                            closesocket(sAccept[iTemp]);
                            sAccept[iTemp] = INVALID_SOCKET;
                            i--;
                            printf("Failed to recv data ,%s:%d errorcode:%d.iTemp=%d\r\n",
                                inet_ntoa(addrTemp.sin_addr),ntohs(addrTemp.sin_port),WSAGetLastError(),iTemp);


                            continue;
                        }

                        // 客户socket关闭
                        if (0 == iRecvSize) 
						{
                            printf("%s:%d has closed iTemp=%d!\r\n",inet_ntoa(addrTemp.sin_addr),
                                ntohs(addrTemp.sin_port),iTemp);

                            closesocket(sAccept[iTemp]);

							sAccept[iTemp] = INVALID_SOCKET;
                            
                            i--;
                        }

                        // no error occurs, returns the number of bytes received
                        if (0 < iRecvSize) 
						{
                            printf("iTemp=%d recv %s:%d data:%s\r\n",iTemp, inet_ntoa(addrTemp.sin_addr),
                                ntohs(addrTemp.sin_port),szDataBuff);
                            char szEcho[2560] = {0};
                            sprintf(szEcho, "Server has got: %s.", szDataBuff);
                            send(sAccept[iTemp], szEcho, strlen(szEcho), 0);
                            closesocket(sAccept[iTemp]);
							sAccept[iTemp] = INVALID_SOCKET;
							
                        }
                    }
                }
			  }
            }
        }
		else if (SOCKET_ERROR == iResult) 
        {
            int iErr = WSAGetLastError();
            //WSACleanup();
            printf("Faild to select sockt in server!(Error: %d)\r\n", iErr);
            Sleep(100);
        }
    }
    WSACleanup();

    return 0;
}


cschengvdn
关注
windows select pipe
道法自然
09-12 1819
转载自：http://blog.csdn.net/chief1985/article/details/5064998 在进行socket编程时，经常会采用select或epoll来接受并发请求。在有些系统里面（例如嵌入式设备），是不支持epoll的，这时只能用select。 Select定义如下： int select(int n, fd_set *rd_fds, fd_set *wr
Windows C++ TCP开发（使用select函数以及设置非阻塞/Reuse属性）
最新发布
2403_83063732的博客
03-13 1470
Windows C++ 使用winsock实现TCP客户端以及服务端，并使用select函数进行IO复用,以及设置非阻塞、端口复用属性
win_select
03-18
网络库开发，windows select
Windows I/O模型之一：Select模型
12-13 145
1.概念理解 在进行网络编程时，我们常常见到同步（Sync）/异步（Async）,阻塞（Block）/非阻塞（Unblock） 四种调用模式： 同步：所谓同步，就是在发出一个功能调用时，在没有得到结果前，该调用就不返回。也就是必须一件 一件做事，等前一件做完了才能做另一件。 例如在C/S模式的某个流程中，你服务器提交了某个请求，在服务器处理完毕返回结果期间客户端什...
windows的select函数
stone-jin
12-23 6459
select的大概思想：将多个套接字放在一个集合里，然后统一检查这些套接字的状态（可读、可写、异常等），调用select后，会更新这些套接字的状态，然后做判断，如果套接字可读，就执行read操作。这样就巧妙地避免了阻塞，达到同时处理多个连接的目的。当然如果没有事件发生，select会一直阻塞，如果不想一直让它等待，想去处理其它事情，可以设置一个最大的等待时间。 int sel
Windows下select模型
波波诸葛伟
09-21 4535
https://blog.csdn.net/hq354974212/article/details/76154849 阻塞模式和非阻塞模式的优点和不足:        阻塞模式套接字执行IO操作时，如果执行操作的条件未满足，线程就会阻塞在调用的函数上。程序不得不处于等待状态，但是由于并不知道客户请求何时到来，因此函数在何时返回不得而知。       非阻塞模式套接字执行IO操作时，在任何...
5种Windows网络模型之select模型
nthzduang_的博客
04-09 3906
  在Windows环境下用C语言实现CS模型中我们详细介绍了网络通信中需要使用的几个函数并指出了最基本的CS模型存在的缺点，为了克服这些缺点，人们提出了select模型，select模型和CS模型相比有以下几个优势： 解决了基本CS模型中accept与recv函数等待连接和等待消息时程序的阻塞。 实现多个客户端连接，能够接收多个客户端的消息 select模型仅用于服务器端 1. select模型原理 每个客户端都有一个socket，服务器也有自己的socket，将所有的socket放进一个数据结构里
windows下基于select模式的TCP客户端（Qt多线程工程）
12-13
windows下基于select网络模式的TCP客户端源码。使用多线程处理接收（Qt多线程工程），select模型解决了实现多个客户端链接，与多个客户端分别通信 两个模型都存在recv(),send()执行阻塞问题
windows网络编程（二）select模型
04-06
windows网络编程（二）select模型思维导图
c++实现win socket 编程中的Select I/O模型
01-28
本文将深入探讨如何使用C++在Windows环境下实现Socket编程中的Select I/O模型。Select模型是一种经典的多路复用I/O机制，它允许单个进程同时监控多个文件描述符（包括套接字）的状态，以检测何时可以进行读写操作。 ...
windows下select和socket配合实现多路复用技术
03-14
windows 下用c实现聊天平台需要解决的问题
select选择模型 windows套接字I/O模型
05-13
select选择模型 windows套接字I/O模型 网络程序设计 运行此程序 还有个客户端程序（上传的TCP里面有）
WIN32 select 模型之客户端
12-06
WIN32平台下 select 模型客户端的简单聊天对话代码,vs2008可以打开
windows tcp server select
weixin_30551947的博客
07-31 272
#include <stdio.h>#include <tchar.h>#include <winsock2.h>#include <iostream>#pragma comment(lib,"ws2_32.lib")using namespace std;fd_set socketSet;SOCKET sockSrv;//accept t...
windows套接字I/0模型-选择(select)模型
人饭子的博客
05-08 692
使用 select 模型需要创建 socket、绑定 IP 和端口、监听连接请求、初始化 fd_set 集合、调用 select 函数、处理可读或可写的文件描述符等步骤。当 select 函数返回时，需要遍历 fd_set 集合，找到其中变为可读或可写的文件描述符，并进行相关处理。// 当有事件发生时，select函数移除fdRead集合中没有未决I/O操作的套节字句柄，然后返回。在每次调用 select 函数前，需要对 fd_set 集合进行重置，以便将之前的状态清空。// 此服务器监听的端口号。
windows平台select使用
技术之路
08-05 4665
服务器端 #include #include #include #define InternetAddr "127.0.0.1" #define iPort 6000 #pragma comment(lib, "ws2_32.lib") void main() { WSADATA wsa; WSAStartup(MAKEWORD(2, 2), &wsa);
Windows操作系统I/O模型—笔记1（select (选择模型)）
AlanHand的专栏
08-11 984
select函数可在socket编程中使用，是一种异步IO选 择模型，可以解决套接字（listen，bind，accept，recv这 几个函数会死锁）死锁， 以下笔记仅为个人学习中的记录，有错请提出，3Q  █ select 的函数原型如下： int  select  (   __in             int nfds
windows下比较好的select模型.
山水人间。
01-05 1759
原文转载自:https://www.cnblogs.com/qiyueliuguang/archive/2013/12/31/3498705.html #include #include using namespace std; #pragma comment(lib, "ws2_32") int main(int argc, char **argv)
Windows中的select网络模型
qq_35426012的博客
08-20 340
网络模型是为了更好的利用资源，优化服务器 因为一个连接产生一个socket,所以维护大量的客户端必须得用多线程处理不同的客户端，而用以前的一个客户端创建一个线程去维护处理又会有新问题 线程最大是一个2个字节的数量（65535）,如果超过的话这种就处理不了，所以就希望一个线程处理多个客户端，所以可以建立一个socket的数组去处理 而一个线程处理多少个客户端合适呢，经过科学计算，处理64个是最好的...
windows select2018
09-14
对于您的问题，基于您提供的引用信息，我可以告诉您关于Windows Select模型的一些基本信息。 Windows Select模型是一种网络编程模型，用于处理多个网络连接。它使用select函数来监视多个套接字，以确定哪些套接字已准备好进行读取或写入操作。具体而言，select函数会阻塞等待，直到至少有一个套接字准备好进行I/O操作。 根据的引用，Windows下基于select网络模式的TCP客户端源码可以使用多线程来处理接收操作，并且使用select模型可以实现与多个客户端分别通信。这种模型的一个优点是能够同时处理多个并发连接，而不需要为每个连接创建一个线程。 至于"Windows Select2018"这个词组，我在提供的引用信息中没有找到具体的相关内容。因此，我不能提供任何关于"Windows Select2018"的详细信息。 希望这能对您有所帮助！如果您还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值