C ++套接字和压力测试
问题描述 投票：0回答：2
我用C ++（MinGW）编写了一个非常简单的套接字服务器，使用这些常用函数
socket( PF_INET, SOCK_STREAM, 0 )...
setsockopt( s, SOL_SOCKET, SO_REUSEADDR, &OptVal, sizeof( OptVal ) )...
bind( s, ( struct sockaddr * ) &ServerAddress, sizeof( ServerAddress ) )...
listen( s, 10 )...
多个客户端连接的处理由
select( s, &FileDescriptorClient, NULL, NULL, &tv )...
accept( Server->GetSocketHandle(), (struct sockaddr*) &ClientAddress, &Length )...
一切看起来都很漂亮，......直到我决定对我的服务器进行压力测试。
我的第一个测试是一个非常简单的客户端，它只做了一件事：尽可能快地连接和断开无限循环。虽然这个测试非常简单，但它立即失败了。
这对我来说并不是太大的意外，服务器会阻塞这么多的连接，所以我在每次连接和断开连接之前在客户端添加了Sleep（5）（毫秒），一切正常。目前。
我的问题是：
- 如何正确处理这些重新连接？
- 什么是压力测试套接字服务器应用程序的正确方法？
现在程序如下：
- 客户端：使用connect（...）连接到服务器
- server：新连接由select（...）和accept（...）识别。每个新连接都存储到std :: vector。
- 客户端：使用closesocket（...）断开与服务器的连接（MinGW ...）
- server：recv（...）读取0个字节，表示客户端与服务器断开连接
- server：执行closesocket（...）并从std :: vector中删除连接
- 每1
如前所述：这只有在我用睡眠限制客户端时才会起作用。一旦我减少休眠时间，服务器就开始跳过pt。 4（断开连接）和库存打开连接线。
我错过了什么？
编辑：
- 服务器在单个线程中运行
- 客户端套接字是非阻塞的
编辑2：
根据要求：源代码（剪切到最小版本）：
服务器的main.cpp：
#include <iostream>
#include "Server.h"
using namespace std;
int main()
{
try
{
ServerSocket srv;
while ( true )
{
srv.Open();
srv.Run();
}
}
catch( ServerException const &e )
{
std::cout << "failed to run the server" << e.what() << std::endl;
}
return 0;
}
Server.h：
#ifndef SERVER_H
#define SERVER_H
#define SOCKETBUFLEN 10
#include <string>
#include <cstdio>
#include <vector>
#include <memory>
#include <unistd.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <sys/types.h>
class Exception : public std::exception
{
private:
std::string Message;
public:
template< typename ... Arguments >
Exception( const char * AFormat, Arguments&& ... AArguments )
{
char Buffer[ 1024 ];
sprintf( Buffer, AFormat, std::forward<Arguments>( AArguments ) ... );
Message = std::string( Buffer );
};
const char* what() const noexcept{ return Message.c_str(); }
};
class ServerException : public Exception
{
public:
template< typename ... Arguments >
ServerException( const char * AFormat, Arguments&& ... AArguments ) : Exception( AFormat, std::forward< Arguments >( AArguments ) ... ){}
};
class ClientException : public Exception
{
public:
template< typename ... Arguments >
ClientException( const char * AFormat, Arguments&& ... AArguments ) : Exception( AFormat, std::forward< Arguments >( AArguments ) ... ){}
};
class Client
{
public:
Client();
virtual ~Client();
virtual bool Authenticate( const std::string & AClientId ) = 0;
virtual bool Process( const std::string & AMessage ) = 0;
protected:
std::vector< std::string > Clients;
private:
};
class ServerSocket;
class ClientSocket;
class Socket;
class ClientSockets
{
private:
ServerSocket *OwnerServer;
fd_set FileDescriptorClient;
std::vector< ClientSocket * > Items;
std::vector< Socket * > SocketsRead;
void Append( ClientSocket * );
void OnClientConnect( SOCKET ASocketHandle, struct sockaddr_in AClientAddress );
public:
ClientSockets( ServerSocket * );
int Count( void );
void Remove( SOCKET ASocketHandle );
bool HandleConnnections( void );
void Read( void );
};
class Socket
{
protected:
SOCKET SocketHandle;
public:
Socket( SOCKET ASocketHandle = 0 ) { SocketHandle = ASocketHandle; };
SOCKET GetSocketHandle( void ) { return SocketHandle; };
virtual void Close( void ) = 0;
};
class ServerSocket : public Socket
{
public:
ServerSocket( const std::string &AHost = "127.0.0.1", const int &APort = 24442 );
virtual ~ServerSocket();
void Open( void );
void Close( void ) {};
void Run( void );
fd_set FileDescriptorServer;
private:
std::string Host;
int Port;
ClientSockets *clientSockets;
};
class ClientSocket : public Socket
{
private:
ClientSockets *FClientSockets;
public:
ClientSocket( ClientSockets *, SOCKET ASocketHandle );
virtual ~ClientSocket() {};
void Close( void );
};
#endif // SERVER_H
Server.cpp：
#include "Server.h"
#include <cstring>
#include <cstdarg>
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <thread>
#include <chrono>
#define LOG_CONNECTION_AMOUNT 100
ServerSocket::ServerSocket( const std::string &AHost, const int &APort ) :
Host( AHost ),
Port( APort ),
clientSockets( new ClientSockets( this ) ) {}
ServerSocket::~ServerSocket()
{
WSACleanup();
}
void ServerSocket::Open( void )
{
WSADATA wsa;
if ( WSAStartup( MAKEWORD( 2, 2 ), &wsa ) != 0 )
{
throw ServerException( "WSAStartup failed" );
}
if ( ( SocketHandle = socket( PF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
throw ServerException( "%s: unable to get a socket handle. errno: %ld", __PRETTY_FUNCTION__, errno );
}
char OptVal = 1;
if ( setsockopt( SocketHandle, SOL_SOCKET, SO_REUSEADDR, &OptVal, sizeof( OptVal ) ) == -1 )
{
throw ServerException( "%s: setsockopt failed", __PRETTY_FUNCTION__ );
}
struct sockaddr_in ServerAddress;
memset( & ServerAddress, 0x0, sizeof( ServerAddress ) );
ServerAddress.sin_family = AF_INET;
ServerAddress.sin_addr.s_addr = inet_addr( Host.c_str() );
ServerAddress.sin_port = htons( Port );
if ( bind( SocketHandle, ( struct sockaddr * ) &ServerAddress, sizeof( ServerAddress ) ) == -1 )
{
throw ServerException( "%s: binding server address failed", __PRETTY_FUNCTION__ );
}
if ( listen( SocketHandle, 10 ) == -1 )
{
throw ServerException( "%s: listen socket failed", __PRETTY_FUNCTION__ );
}
FD_ZERO( &FileDescriptorServer );
FD_SET( SocketHandle, &FileDescriptorServer );
std::cout << "socket server fd '" << SocketHandle << "' listening on " << Host << ":" << Port << std::endl;
}
void ServerSocket::Run( void )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
do
{
try
{
if ( !clientSockets->HandleConnnections() )
{
continue;
}
clientSockets->Read();
}
catch( ServerException const &e )
{
int ErrorCode = WSAGetLastError();
std::cout << "error while server running: " << e.what() << ", code: " << ErrorCode << std::endl;
if ( ErrorCode == 10038 ) // no socket error
{
// continue; // not sure if this is the correct way to do...
}
// if ( ErrorCode == 10014 ) {} // bad address error
// if ( ErrorCode == 10054 ) {} // connection reset by peer
break;
}
catch( ... )
{
std::cout << "some exception occurred" << std::endl;
}
} while ( true );
}
ClientSockets::ClientSockets( ServerSocket * AOwnerServer )
{
OwnerServer = AOwnerServer;
}
void ClientSockets::Append( ClientSocket *AClientSocket )
{
Items.push_back( AClientSocket );
}
int ClientSockets::Count( void )
{
return Items.size();
}
bool ClientSockets::HandleConnnections( void )
{
FD_ZERO( & FileDescriptorClient );
SocketsRead.clear();
SocketsRead.push_back( OwnerServer );
for ( auto i : Items )
{
SocketsRead.push_back( i );
}
for ( auto Socket : SocketsRead )
{
if ( FD_ISSET( Socket->GetSocketHandle(), & OwnerServer->FileDescriptorServer ) )
{
FD_SET( Socket->GetSocketHandle(), & FileDescriptorClient );
}
}
struct timeval tv;
tv.tv_sec = 10;
tv.tv_usec = 3;
int SocketChangedCount = 0;
if ( ( SocketChangedCount = select( 0, &FileDescriptorClient, NULL, NULL, &tv ) ) == -1 )
{
throw ServerException( "%s: select failed", __PRETTY_FUNCTION__ );
}
static int scc = 0;
if ( scc != SocketChangedCount )
{
scc = SocketChangedCount;
std::cout << "socket changes: " << SocketChangedCount << std::endl;
}
if ( FD_ISSET( OwnerServer->GetSocketHandle(), &FileDescriptorClient ) )
{
struct sockaddr_in ClientAddress;
socklen_t Length = sizeof( ClientAddress );
SOCKET SocketHandle = 0;
if ( ( SocketHandle = accept( OwnerServer->GetSocketHandle(), (struct sockaddr*) &ClientAddress, &Length ) ) == INVALID_SOCKET )
{
throw ServerException( "%s: accept failed", __PRETTY_FUNCTION__ );
}
else
{
OnClientConnect( SocketHandle, ClientAddress );
}
FD_SET( SocketHandle, &OwnerServer->FileDescriptorServer );
}
return ( SocketChangedCount > 0 );
}
void ClientSockets::OnClientConnect( SOCKET ASocketHandle, struct sockaddr_in AClientAddress )
{
#if LOG_CONNECTION_AMOUNT > 0
static int ClientConnectionCounter = 0;
if ( ClientConnectionCounter++ % LOG_CONNECTION_AMOUNT == 0 )
{
std::cout << "connect fd: [" << ASocketHandle << "], serial: [" << ClientConnectionCounter << "], cnt: [" << Count() << "]" << std::endl;
}
#endif
ClientSocket *clientSocket = new ClientSocket( this, ASocketHandle );
Append( clientSocket );
}
void ClientSockets::Read( void )
{
for ( auto clientSocket : Items )
{
if ( FD_ISSET( clientSocket->GetSocketHandle(), &FileDescriptorClient ) )
{
char buf[ SOCKETBUFLEN + 1 ];
memset( buf, 0x0, sizeof( buf ) );
int BytesReceived = recv( clientSocket->GetSocketHandle(), buf, SOCKETBUFLEN, 0 );
if ( BytesReceived > 0 )
{
std::string Message = ( std::string ) buf;
if ( Message.substr( 0, 4 ) == "quit" )
{
clientSocket->Close();
break;
}
else
{
// ... do fancy stuff here...
std::cout << "read from socket: " << Message << std::endl;
}
}
else if ( BytesReceived == 0 )
{
clientSocket->Close();
break;
}
else
{
throw ServerException( "reading data failed" );
}
}
}
}
void ClientSockets::Remove( SOCKET ASocketHandle )
{
FD_CLR( ASocketHandle, & FileDescriptorClient );
std::vector< ClientSocket * >::iterator it =
Items.erase(
std::remove_if(
Items.begin(),
Items.end(),
[ ASocketHandle ]( Socket *sock ){ return sock->GetSocketHandle() == ASocketHandle; }
)
);
delete *it;
}
void ClientSocket::Close( void )
{
#if LOG_CONNECTION_AMOUNT > 0
static int ClientDisconnectionCounter = 0;
if ( ClientDisconnectionCounter++ % LOG_CONNECTION_AMOUNT == 0 )
{
std::cout << "disconnnect fd: [" << SocketHandle << "], serial: [" << ClientDisconnectionCounter << "], cnt: [" << FClientSockets->Count() << "]" << std::endl;
}
#endif
if ( closesocket( SocketHandle ) == SOCKET_ERROR )
{
throw ClientException( "closing socket failed: %ld", errno );
}
FClientSockets->Remove( SocketHandle );
}
ClientSocket::ClientSocket( ClientSockets *AClientSockets, SOCKET ASocketHandle ) :
Socket( ASocketHandle ),
FClientSockets( AClientSockets ) {}
测试客户端应用程序是非常原始的：我使用Embarcadero C ++ Builder和TClientSocket组件，该组件不断切换其连接状态（在非阻塞模式下）。 3个复选框用于告诉应用程序以循环模式（1）运行，在连接前睡眠（2）和断开前睡眠（3）以及1 TEdit用于修改睡眠持续时间（以毫秒为单位）。
cpp文件的代码是：
#include <vcl.h>
#pragma hdrstop
#include "UnitFormMain.h"
#pragma package(smart_init)
#pragma resource "*.dfm"
TFormMain *FormMain;
//---------------------------------------------------------------------------
__fastcall TFormMain::TFormMain(TComponent* Owner)
: TForm(Owner), Trigger( false ), sock( 0 )
{
}
//---------------------------------------------------------------------------
void __fastcall TFormMain::ClientSocket1Connect(TObject *Sender, TCustomWinSocket *Socket)
{
static int ConnectionCounter = 0;
if ( ConnectionCounter++ % 100 == 0 )
{
Memo1->Lines->Add( System::Sysutils::Format( "connectionCounter '%d'", ARRAYOFCONST(( ConnectionCounter )) ) );
}
if ( CheckBoxRunLoopComponent->Checked )
{
Trigger = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TFormMain::ClientSocket1Disconnect(TObject *Sender, TCustomWinSocket *Socket)
{
if ( CheckBoxRunLoopComponent->Checked )
{
Trigger = true;
}
}
//---------------------------------------------------------------------------
void __fastcall TFormMain::ButtonToggleConnectionComponentClick(TObject *Sender)
{
ClientSocket1->Active = !ClientSocket1->Active;
}
//---------------------------------------------------------------------------
void __fastcall TFormMain::CheckBoxRunLoopComponentClick(TObject *Sender)
{
if ( dynamic_cast< TCheckBox * >( Sender )->Checked )
{
for (;;)
{
Application->ProcessMessages();
if ( !dynamic_cast< TCheckBox * >( Sender )->Checked )
{
break;
}
ToggleConnection();
}
}
}
void TFormMain::ToggleConnection( void )
{
if ( Trigger )
{
Trigger = false;
if ( ClientSocket1->Active )
{
if ( CheckBoxSleepOnDisconnect )
{
Sleep( StrToInt( Edit1->Text ) );
}
ClientSocket1->Close();
}
else
{
if ( CheckBoxSleepOnConnect->Checked )
{
Sleep( StrToInt( Edit1->Text ) );
}
ClientSocket1->Open();
}
}
}
//---------------------------------------------------------------------------
更有趣的是测试运行（服务器）的输出：
每个第100个切换都是协议的。 “cnt”是std :: vector <>中的连接数。
测试在每个切换开始时以5毫秒的睡眠时间开始。在第1500次切换时，我将休眠时间减少到1毫秒，这导致服务器列表中的活动连接立即增加。几千个连接后来select()与10038失败。
socket server fd '276' listening on 127.0.0.1:24442
void ServerSocket::Run()
socket changes: 1
connect fd: [280], serial: [1], cnt: [0]
disconnnect fd: [280], serial: [1], cnt: [1]
connect fd: [284], serial: [101], cnt: [0]
disconnnect fd: [284], serial: [101], cnt: [1]
connect fd: [280], serial: [201], cnt: [0]
disconnnect fd: [280], serial: [201], cnt: [1]
connect fd: [288], serial: [301], cnt: [0]
disconnnect fd: [288], serial: [301], cnt: [1]
connect fd: [292], serial: [401], cnt: [0]
disconnnect fd: [292], serial: [401], cnt: [1]
connect fd: [296], serial: [501], cnt: [0]
disconnnect fd: [296], serial: [501], cnt: [1]
connect fd: [308], serial: [601], cnt: [0]
disconnnect fd: [308], serial: [601], cnt: [1]
connect fd: [296], serial: [701], cnt: [0]
disconnnect fd: [296], serial: [701], cnt: [1]
connect fd: [296], serial: [801], cnt: [0]
disconnnect fd: [296], serial: [801], cnt: [1]
connect fd: [288], serial: [901], cnt: [0]
disconnnect fd: [288], serial: [901], cnt: [1]
connect fd: [300], serial: [1001], cnt: [0]
disconnnect fd: [300], serial: [1001], cnt: [1]
connect fd: [312], serial: [1101], cnt: [0]
disconnnect fd: [312], serial: [1101], cnt: [1]
connect fd: [300], serial: [1201], cnt: [0]
disconnnect fd: [300], serial: [1201], cnt: [1]
connect fd: [300], serial: [1301], cnt: [0]
disconnnect fd: [300], serial: [1301], cnt: [1]
connect fd: [280], serial: [1401], cnt: [0]
disconnnect fd: [280], serial: [1401], cnt: [1]
connect fd: [280], serial: [1501], cnt: [0]
disconnnect fd: [280], serial: [1501], cnt: [1]
connect fd: [316], serial: [1601], cnt: [0]
socket changes: 2
disconnnect fd: [316], serial: [1601], cnt: [2]
socket changes: 1
socket changes: 2
socket changes: 1
socket changes: 2
socket changes: 1
connect fd: [312], serial: [1701], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [312], serial: [1701], cnt: [4]
connect fd: [324], serial: [1801], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [312], serial: [1801], cnt: [4]
connect fd: [324], serial: [1901], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [324], serial: [1901], cnt: [4]
connect fd: [320], serial: [2001], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [320], serial: [2001], cnt: [4]
socket changes: 2
socket changes: 1
connect fd: [336], serial: [2101], cnt: [3]
disconnnect fd: [336], serial: [2101], cnt: [4]
connect fd: [344], serial: [2201], cnt: [3]
disconnnect fd: [344], serial: [2201], cnt: [4]
connect fd: [344], serial: [2301], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [336], serial: [2301], cnt: [4]
socket changes: 2
socket changes: 1
connect fd: [344], serial: [2401], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [336], serial: [2401], cnt: [4]
connect fd: [344], serial: [2501], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [344], serial: [2501], cnt: [4]
connect fd: [344], serial: [2601], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [344], serial: [2601], cnt: [4]
connect fd: [332], serial: [2701], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [332], serial: [2701], cnt: [4]
connect fd: [344], serial: [2801], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [332], serial: [2801], cnt: [4]
socket changes: 2
socket changes: 1
connect fd: [328], serial: [2901], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [324], serial: [2901], cnt: [4]
socket changes: 2
socket changes: 1
connect fd: [328], serial: [3001], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [324], serial: [3001], cnt: [4]
socket changes: 2
socket changes: 1
connect fd: [328], serial: [3101], cnt: [3]
socket changes: 2
socket changes: 1
disconnnect fd: [324], serial: [3101], cnt: [4]
connect fd: [324], serial: [3201], cnt: [3]
disconnnect fd: [324], serial: [3201], cnt: [4]
connect fd: [324], serial: [3301], cnt: [3]
disconnnect fd: [324], serial: [3301], cnt: [4]
socket changes: 2
socket changes: 1
error while server running: bool ClientSockets::HandleConnnections(): select failed, code: 10038
socket server fd '324' listening on 127.0.0.1:24442
void ServerSocket::Run()
socket changes: 0
在这个协议中我也看到select()返回一个值> 1（“Socket changes：n”），这意味着多于一个套接字改变了它的状态。我认为这可能是指向正确解决方案的指针，但是现在我不知道如何以正确的方式处理这个问题。
编辑3：阻塞/无阻塞：在CPPBuilder中，您可以使用这些设计时组件，您可以在设计时设置属性：
2个回答
1
投票
投票
我不确定你的代码有什么问题 - 对我来说这太复杂了，所以相反，我发布了一些我自己的代码，你可以使用它作为指导。
这个代码在客户端使用Sleep(1)工作正常（虽然这并不是你可能认为的那样）。下面还有一些注释。
#define FD_SETSIZE 4096
#include <WinSock2.h> // ** before** windows.h
#include <WS2tcpip.h>
#include <windows.h>
#include <iostream>
#include <set>
#include <assert.h>
#pragma comment (lib, "ws2_32.lib")
const int port = 24442;
std::set <SOCKET> connected_sockets;
// main
int main (char argc, char* argv[])
{
WSADATA wsadata;
WORD version = MAKEWORD(2, 2);
int err = WSAStartup (MAKEWORD (2, 2), &wsadata);
if (err)
{
std::cout << "WSAStartup failed, error: " << err << std::endl;
return 255;
}
char buf [512];
bool is_client = argc > 1 && _stricmp (argv [1], "client") == 0;
if (is_client)
{
int lap = 0;
for ( ; ; )
{
// Client
SOCKET skt = socket (AF_INET, SOCK_STREAM, 0);
assert (skt != INVALID_SOCKET);
sockaddr_in server_address = { };
server_address.sin_family = AF_INET;
server_address.sin_port = htons (port);
inet_pton (AF_INET, "192.168.1.2", &server_address.sin_addr);
std::cout << ++lap << ": Connecting..." << std::endl;
int err = connect (skt, (const sockaddr *) &server_address, sizeof (server_address));
if (err)
{
std::cout << "connect() failed, error: " << WSAGetLastError () << std::endl;
Sleep (50);
continue;
}
memset (buf, 'Q', sizeof (buf));
std::cout << "Sending..." << std::endl;
if (send (skt, buf, sizeof (buf), 0) == SOCKET_ERROR)
std::cout << "send() failed, error: " << WSAGetLastError () << std::endl;
std::cout << "Disconnecting..." << std::endl;
closesocket (skt);
Sleep (1);
}
WSACleanup ();
return 0;
}
// Server
SOCKET listener_skt = socket (AF_INET, SOCK_STREAM, 0);
assert (listener_skt != INVALID_SOCKET);
sockaddr_in receive_address = { };
receive_address.sin_family = AF_INET;
receive_address.sin_port = htons (port);
receive_address.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (listener_skt, (const sockaddr *) &receive_address, sizeof (receive_address)) == -1)
{
std::cout << "bind failed , error: " << errno << std::endl;
return 255;
}
if (listen (listener_skt, 256) == SOCKET_ERROR)
{
std::cout << "listen() failed, error: " << WSAGetLastError () << std::endl;
return 255;
}
std::cout << "Listening..." << std::endl;
for ( ; ; )
{
fd_set read_fds;
FD_ZERO (&read_fds);
FD_SET (listener_skt, &read_fds); // listener_skt must be first
int n_fds = 0;
for (auto skt : connected_sockets)
{
FD_SET (skt, &read_fds);
if (++n_fds >= FD_SETSIZE - 1)
break;
}
n_fds = select (0, &read_fds, NULL, NULL, NULL);
if (n_fds <= 0)
{
if (n_fds < 0)
std::cout << "select failed, error: " << WSAGetLastError () << std::endl;
continue;
}
int i = 0;
if (read_fds.fd_array [i] == listener_skt)
{
SOCKET skt = accept (listener_skt, NULL, 0);
if (skt == SOCKET_ERROR)
std::cout << "accept() failed, error: " << WSAGetLastError () << std::endl;
else
{
std::cout << "Accepted connection on socket: " << skt << std::endl;
connected_sockets.insert (skt);
}
++i;
}
while (i < n_fds)
{
SOCKET skt = read_fds.fd_array [i];
int nbytes = recv (skt, buf, sizeof (buf), 0);
if (nbytes > 0)
std::cout << "Received " << nbytes << " bytes on socket " << skt << std::endl;
else
{
std::cout << "Socket " << skt << " disconnected, code: " << nbytes << std::endl;
closesocket (skt);
connected_sockets.erase (skt);
}
++i;
}
}
closesocket (listener_skt);
WSACleanup ();
return 0;
}
用法：
test_program - 作为服务器运行
test_program client - 作为客户运营
笔记：
- 在#include
FD_SETSIZE之前，你必须#define（然后尊重）WinSock2.h。你的代码没有这样做（=潜在的内存覆盖，这可能是导致你麻烦的事情之一）。 - 您对
backlog的listen()参数太小，会导致客户端被告知在服务器繁忙时无法连接（请参阅here）。我去了256，但你选择的价值应该由你的用例和测试结果决定。 - 一个更好的压力测试（这是你提出的问题之一）是让几个客户端同时使用连接请求来处理服务器，（我建议）在客户端使用更真实的
Sleep时间。我用Sleep(50)尝试了5个客户端，它运行了15分钟或更长时间而没有发生任何事故。 - 对于服务器来说，
std::set是一种更好的方式来跟踪它连接的SOCKETs而不是vector，请参阅代码。这就是std::set的设计目标。
希望这指明了方向。如果您有任何问题，请告诉我（我喜欢编写网络代码:)。
0
投票
投票
我的代码有几个非常严重的问题，现在我认为我修复了它们。也许。
必须在服务器上进行四项主要更改。
改变＃1：当select（）返回2时，只调用一次accept（）是错误的。
当select（）返回大于1的值时，我已经认为我的原始代码是错误的。通常这（几乎）永远不会发生，因此我在过去十年的所有套接字应用程序中都有此错误任何影响。所以我更改了代码：
int SocketChangedCount = 0;
if ( ( SocketChangedCount = select( 0, &FileDescriptorClient, NULL, NULL, &tv ) ) == -1 )
{
throw ServerException( "%s: select failed", __PRETTY_FUNCTION__ );
}
if ( FD_ISSET( OwnerServer->GetSocketHandle(), &FileDescriptorClient ) )
{
struct sockaddr_in ClientAddress;
socklen_t Length = sizeof( ClientAddress );
SOCKET SocketHandle = 0;
// change N° 1:
// the return value of select is the number of new connections.
// therefore we need to call accept for EACH new connection.
// this issue did never light up, because the connections have
// to be established almost simultaneously to trigger this issue.
for ( int i = 0; i < SocketChangedCount; ++i )
{
if ( ( SocketHandle = accept( OwnerServer->GetSocketHandle(), (struct sockaddr*) &ClientAddress, &Length ) ) == INVALID_SOCKET )
{
throw ServerException( "%s: accept failed", __PRETTY_FUNCTION__ );
}
else
{
OnClientConnect( SocketHandle, ClientAddress );
}
FD_SET( SocketHandle, &OwnerServer->FileDescriptorServer );
}
}
改变＃2：虽然这不是主要问题，但积压大小显然很小：
// change N° 2:
// a backlog parameter of "10" is not enough. SOMAXCONN should be the preferable value
// if ( listen( SocketHandle, 10 ) == -1 )
if ( listen( SocketHandle, SOMAXCONN ) == -1 )
{
throw ServerException( "%s: listen socket failed", __PRETTY_FUNCTION__ );
}
改变＃3：我将std :: vector更改为std :: unordered_map：
// change N° 3:
std::unordered_map< SOCKET, ClientSocket * > Items;
// std::vector< Socket * > SocketsRead;
偶然这也解决了我以前没有注意到的错误：删除已注销的客户端是完全错误的：
void ClientSockets::Remove( SOCKET ASocketHandle )
{
FD_CLR( ASocketHandle, & FileDescriptorClient );
/*
// whatever this code did: it was wrong
std::vector< ClientSocket * >::iterator it =
Items.erase(
std::remove_if(
Items.begin(),
Items.end(),
[ ASocketHandle ]( Socket *sock ){ return sock->GetSocketHandle() == ASocketHandle; }
)
);
delete *it;
*/
std::unordered_map< SOCKET, ClientSocket * >::iterator it = Items.find( ASocketHandle );
if ( it != Items.end() )
{
Items.erase( it );
}
}
改变＃4：最后但并非最不重要：过早分手
每当客户端断开连接时我都会中断循环。愚蠢的我。
void ClientSockets::Read( void )
{
for ( auto clientSocket : Items )
{
if ( FD_ISSET( clientSocket.first, &FileDescriptorClient ) )
{
char buf[ SOCKETBUFLEN + 1 ];
memset( buf, 0x0, sizeof( buf ) );
int BytesReceived = recv( clientSocket.first, buf, SOCKETBUFLEN, 0 );
if ( BytesReceived > 0 )
{
std::string Message = ( std::string ) buf;
if ( Message.substr( 0, 4 ) == "quit" )
{
clientSocket.second->Close();
continue;
// break;
}
else
{
// ... do fancy stuff here...
std::cout << "read from socket: " << Message << std::endl;
}
}
else if ( BytesReceived == 0 )
{
clientSocket.second->Close();
// change N° 4:
// breaking the loop is a really bad idea
continue;
// break;
}
else
{
throw ServerException( "reading data failed" );
}
}
}
}
谢谢你们，我终于能够运行我的压力测试应用程序，发现了一些我从未发现过的问题。
如果其他人喜欢这样做：这是固定代码：
标题：
#ifndef SERVER_H
#define SERVER_H
#define SOCKETBUFLEN 10
#include <string>
#include <cstdio>
#include <unordered_map>
#include <memory>
#include <unistd.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <sys/types.h>
class Exception : public std::exception
{
private:
std::string Message;
public:
template< typename ... Arguments >
Exception( const char * AFormat, Arguments&& ... AArguments )
{
char Buffer[ 1024 ];
sprintf( Buffer, AFormat, std::forward<Arguments>( AArguments ) ... );
Message = std::string( Buffer );
};
const char* what() const noexcept{ return Message.c_str(); }
};
class ServerException : public Exception
{
public:
template< typename ... Arguments >
ServerException( const char * AFormat, Arguments&& ... AArguments ) : Exception( AFormat, std::forward< Arguments >( AArguments ) ... ){}
};
class ClientException : public Exception
{
public:
template< typename ... Arguments >
ClientException( const char * AFormat, Arguments&& ... AArguments ) : Exception( AFormat, std::forward< Arguments >( AArguments ) ... ){}
};
class Client
{
public:
Client();
virtual ~Client();
virtual bool Authenticate( const std::string & AClientId ) = 0;
virtual bool Process( const std::string & AMessage ) = 0;
private:
};
class ServerSocket;
class ClientSocket;
class Socket;
class ClientSockets
{
private:
ServerSocket *OwnerServer;
fd_set FileDescriptorClient;
// change N° 3:
std::unordered_map< SOCKET, ClientSocket * > Items;
// std::vector< Socket * > SocketsRead;
void Append( ClientSocket * );
void OnClientConnect( SOCKET ASocketHandle, struct sockaddr_in AClientAddress );
public:
ClientSockets( ServerSocket * );
int Count( void );
void Remove( SOCKET ASocketHandle );
bool HandleConnnections( void );
void Read( void );
};
class Socket
{
protected:
SOCKET SocketHandle;
public:
Socket( SOCKET ASocketHandle = 0 ) { SocketHandle = ASocketHandle; };
SOCKET GetSocketHandle( void ) { return SocketHandle; };
virtual void Close( void ) = 0;
};
class ServerSocket : public Socket
{
public:
ServerSocket( const std::string &AHost = "127.0.0.1", const int &APort = 24442 );
virtual ~ServerSocket();
void Open( void );
void Close( void ) {};
void Run( void );
fd_set FileDescriptorServer;
private:
std::string Host;
int Port;
ClientSockets *clientSockets;
};
class ClientSocket : public Socket
{
private:
ClientSockets *FClientSockets;
public:
ClientSocket( ClientSockets *, SOCKET ASocketHandle );
virtual ~ClientSocket() {};
void Close( void );
};
#endif // SERVER_H
资源：
#include "Server.h"
#include <cstring>
#include <cstdarg>
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <thread>
#include <chrono>
#define LOG_CONNECTION_AMOUNT 100
ServerSocket::ServerSocket( const std::string &AHost, const int &APort ) :
Host( AHost ),
Port( APort ),
clientSockets( new ClientSockets( this ) ) {}
ServerSocket::~ServerSocket()
{
WSACleanup();
}
void ServerSocket::Open( void )
{
WSADATA wsa;
if ( WSAStartup( MAKEWORD( 2, 2 ), &wsa ) != 0 )
{
throw ServerException( "WSAStartup failed" );
}
if ( ( SocketHandle = socket( PF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
throw ServerException( "%s: unable to get a socket handle. errno: %ld", __PRETTY_FUNCTION__, errno );
}
char OptVal = 1;
if ( setsockopt( SocketHandle, SOL_SOCKET, SO_REUSEADDR, &OptVal, sizeof( OptVal ) ) == -1 )
{
throw ServerException( "%s: setsockopt failed", __PRETTY_FUNCTION__ );
}
struct sockaddr_in ServerAddress;
memset( & ServerAddress, 0x0, sizeof( ServerAddress ) );
ServerAddress.sin_family = AF_INET;
ServerAddress.sin_addr.s_addr = inet_addr( Host.c_str() );
ServerAddress.sin_port = htons( Port );
if ( bind( SocketHandle, ( struct sockaddr * ) &ServerAddress, sizeof( ServerAddress ) ) == -1 )
{
throw ServerException( "%s: binding server address failed", __PRETTY_FUNCTION__ );
}
// change N° 2:
// a backlog parameter of "10" is not enough. SOMAXCONN should be the preferable value
// if ( listen( SocketHandle, 10 ) == -1 )
if ( listen( SocketHandle, SOMAXCONN ) == -1 )
{
throw ServerException( "%s: listen socket failed", __PRETTY_FUNCTION__ );
}
FD_ZERO( &FileDescriptorServer );
FD_SET( SocketHandle, &FileDescriptorServer );
std::cout << "socket server fd '" << SocketHandle << "' listening on " << Host << ":" << Port << std::endl;
}
void ServerSocket::Run( void )
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
do
{
try
{
if ( !clientSockets->HandleConnnections() )
{
continue;
}
clientSockets->Read();
}
catch( ServerException const &e )
{
int ErrorCode = WSAGetLastError();
std::cout << "error while server running: " << e.what() << ", code: " << ErrorCode << std::endl;
if ( ErrorCode == 10038 ) // no socket error
{
// continue; // not sure if this is the correct way to do...
}
// if ( ErrorCode == 10014 ) {} // bad address error
// if ( ErrorCode == 10054 ) {} // connection reset by peer
break;
}
catch( ... )
{
std::cout << "some exception occurred" << std::endl;
}
} while ( true );
}
ClientSockets::ClientSockets( ServerSocket * AOwnerServer )
{
OwnerServer = AOwnerServer;
}
void ClientSockets::Append( ClientSocket *AClientSocket )
{
Items.insert( std::make_pair( AClientSocket->GetSocketHandle(), AClientSocket ) );
}
int ClientSockets::Count( void )
{
return Items.size();
}
bool ClientSockets::HandleConnnections( void )
{
FD_ZERO( & FileDescriptorClient );
std::unordered_map< SOCKET, Socket *> SocketsRead;
SocketsRead.insert( std::make_pair( OwnerServer->GetSocketHandle(), OwnerServer ) );
for ( auto client : Items )
{
SocketsRead.insert( client );
}
for ( auto Socket : SocketsRead )
{
if ( FD_ISSET( Socket.first, & OwnerServer->FileDescriptorServer ) )
{
FD_SET( Socket.first, & FileDescriptorClient );
}
}
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 3;
int SocketChangedCount = 0;
if ( ( SocketChangedCount = select( 0, &FileDescriptorClient, NULL, NULL, &tv ) ) == -1 )
{
throw ServerException( "%s: select failed", __PRETTY_FUNCTION__ );
}
if ( FD_ISSET( OwnerServer->GetSocketHandle(), &FileDescriptorClient ) )
{
struct sockaddr_in ClientAddress;
socklen_t Length = sizeof( ClientAddress );
SOCKET SocketHandle = 0;
// change N° 1:
// the return value of select is the number of new connections.
// therefore we need to call accept for EACH new connection.
// this issue did never light up, because the connections have
// to be established almost simultaneously to trigger this issue.
for ( int i = 0; i < SocketChangedCount; ++i )
{
if ( ( SocketHandle = accept( OwnerServer->GetSocketHandle(), (struct sockaddr*) &ClientAddress, &Length ) ) == INVALID_SOCKET )
{
throw ServerException( "%s: accept failed", __PRETTY_FUNCTION__ );
}
else
{
OnClientConnect( SocketHandle, ClientAddress );
}
FD_SET( SocketHandle, &OwnerServer->FileDescriptorServer );
}
}
return ( SocketChangedCount > 0 );
}
void ClientSockets::OnClientConnect( SOCKET ASocketHandle, struct sockaddr_in AClientAddress )
{
#if LOG_CONNECTION_AMOUNT > 0
static int ClientConnectionCounter = 0;
if ( ClientConnectionCounter++ % LOG_CONNECTION_AMOUNT == 0 )
{
std::cout << "connect fd: [" << ASocketHandle << "], serial: [" << ClientConnectionCounter << "], cnt: [" << Count() << "]" << std::endl;
}
#endif
ClientSocket *clientSocket = new ClientSocket( this, ASocketHandle );
Append( clientSocket );
}
void ClientSockets::Read( void )
{
for ( auto clientSocket : Items )
{
if ( FD_ISSET( clientSocket.first, &FileDescriptorClient ) )
{
char buf[ SOCKETBUFLEN + 1 ];
memset( buf, 0x0, sizeof( buf ) );
int BytesReceived = recv( clientSocket.first, buf, SOCKETBUFLEN, 0 );
if ( BytesReceived > 0 )
{
std::string Message = ( std::string ) buf;
if ( Message.substr( 0, 4 ) == "quit" )
{
clientSocket.second->Close();
continue;
// break;
}
else
{
// ... do fancy stuff here...
std::cout << "read from socket: " << Message << std::endl;
}
}
else if ( BytesReceived == 0 )
{
clientSocket.second->Close();
// change N° 4:
// breaking the loop is a really bad idea
continue;
// break;
}
else
{
throw ServerException( "reading data failed" );
}
}
}
}
void ClientSockets::Remove( SOCKET ASocketHandle )
{
FD_CLR( ASocketHandle, & FileDescriptorClient );
/*
// whatever this code did: it was wrong
std::vector< ClientSocket * >::iterator it =
Items.erase(
std::remove_if(
Items.begin(),
Items.end(),
[ ASocketHandle ]( Socket *sock ){ return sock->GetSocketHandle() == ASocketHandle; }
)
);
delete *it;
*/
std::unordered_map< SOCKET, ClientSocket * >::iterator it = Items.find( ASocketHandle );
if ( it != Items.end() )
{
Items.erase( it );
}
}
void ClientSocket::Close( void )
{
#if LOG_CONNECTION_AMOUNT > 0
static int ClientDisconnectionCounter = 0;
if ( ClientDisconnectionCounter++ % LOG_CONNECTION_AMOUNT == 0 )
{
std::cout << "disconnnect fd: [" << SocketHandle << "], serial: [" << ClientDisconnectionCounter << "], cnt: [" << FClientSockets->Count() << "]" << std::endl;
}
#endif
if ( closesocket( SocketHandle ) == SOCKET_ERROR )
{
throw ClientException( "closing socket failed: %ld", errno );
}
FClientSockets->Remove( SocketHandle );
}
ClientSocket::ClientSocket( ClientSockets *AClientSockets, SOCKET ASocketHandle ) :
Socket( ASocketHandle ),
FClientSockets( AClientSockets ) {}
Main.cpp仍然没有链接。非常感谢！
最新问题
- Pyspark：动态扁平化层次结构表
- c++ DirectX 函数 Present() 不起作用
- Next 13 出现下一个身份验证生产构建错误
- 使用 test -e 检查目录中是否存在文件
- Azure DevOps (https://dev.azure.com/project_name) 循环登录
- 在数据类哈希函数中包含类型
- 将 Application Insight 与 ASP API Core 结合使用
- 如何在批处理脚本中嵌入Python代码
- 标签和输入随着错误的 div 移动
- IIS 重写规则为 React 应用程序提供 Index.html
- storybook 找不到基于 chakra-ui 的组件
- AWS 是否会计算失败的 Rekognition API 调用并因此对这些调用收费？
- Moowoodle - 添加商店中的每个用户
- 隐藏购物篮中没有价格的送货方式 | Woccommerce| WCFM 市场
- 为什么编译器无法推导出这个函数模板类型？ [重复]
- 在 MySQL 中处理巨大的 Blob？
- 如果使用文本字段，如何禁用文件输入
- 可变模板无法编译
- 打开另一个下拉菜单时关闭
- 在 Bicep 中使用客户管理的加密密钥创建 Azure 容器注册表
© www.soinside.com 2019 - 2024. All rights reserved.