新しいスレッドでリクエストを処理するたびにキューを整理する方法は？

Question

新しいスレッドで着信接続の各リクエスト処理を整理するのに助けが必要です（コードはこのトピックの最後です）。

各リクエストを処理する際に手動で（ブースト/スレッドプールを使用せずに）キューを整理する方法はまったくわかりませんか？私はどのように非使用ブーストなどでこのような問題を解決する必要がありますか？

原因、私はそれを手動で行いたい、と私は次に何をどのように理解していない：私は、新しい接続を持っていれば、それぞれの新しい接続

のリスニング

• 、その後、新しいスレッドに送信します私はながら、（真）で、このようなものを行うことを試みた取り扱い
• スレッドが処理プロセス終了すると、

このスレッドを閉じます。しかし、各HTTPリクエストを処理するためにリクエストキューをうまく整理する方法がわかりません。

私のコードは次のとおりです。

#include <iostream> 
#include <Windows.h> 

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

typedef struct Header 
{ 
friend struct Net; 

private: 
    WORD wsa_version; 
    WSAData wsa_data; 

    SOCKET sock; 
    SOCKADDR_IN service; 

    char *ip; 
    unsigned short port; 

public: 
    Header(void) 
    { 
     wsa_version = 0x202; 

     ip = "0x7f.0.0.1"; 
     port = 0x51; 

     service.sin_family = AF_INET; 
     service.sin_addr.s_addr = inet_addr(ip); 
     service.sin_port = htons(port); 
    } 

} Header; 

typedef struct Net 
{ 
private: 
    int result; 

    HANDLE thrd; 
    DWORD exit_code; 

    void WSAInit(WSAData *data, WORD *wsa_version) 
    { 
     result = WSAStartup(*wsa_version, &(*data)); 

     if(result != NO_ERROR) 
     { 
      std::cout << "WSAStartup() failed with the error: " << result << std::endl; 
     } 
     else 
     { 
      std::cout << (*data).szDescription << " " << (*data).szSystemStatus << std::endl; 
     } 
    } 

    void SocketInit(SOCKET *my_socket) 
    { 
     (*my_socket) = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 

     if((*my_socket) == INVALID_SOCKET) 
     { 
      std::cout << "Socket initialization failed with the error: " << WSAGetLastError() << std::endl; 
      WSACleanup(); 
     } 
     else 
     { 
      std::cout << "Socket initialization successful!" << std::endl; 
     } 
    } 

    void SocketBind(SOCKET *my_socket, SOCKADDR_IN *service) 
    { 
     result = bind((*my_socket), (SOCKADDR*)&(*service), sizeof(*service)); 

     if(result == SOCKET_ERROR) 
     { 
      std::cout << "Socket binding failed with the error: " << WSAGetLastError() << std::endl; 
      closesocket((*my_socket)); 
      WSACleanup(); 
     } 
     else 
     { 
      std::cout << "Socket binding successful!" << std::endl; 
     } 

     result = listen(*my_socket, SOMAXCONN); 

     if(result == SOCKET_ERROR) 
     { 
      std::cout << "Socket listening failed with the error: " << WSAGetLastError() << std::endl; 
     } 
     else 
     { 
      std::cout << "Listening to the socket..." << std::endl; 
     } 
    } 

    void SocketAccept(SOCKET *my_socket) 
    { 
     SOCKET sock_accept = accept((*my_socket), 0, 0); 

     if(sock_accept == INVALID_SOCKET) 
     { 
      std::cout << "Accept failed with the error: " << WSAGetLastError() << std::endl; 
      closesocket(*my_socket); 
      WSACleanup(); 
     } 
     else 
     { 
      std::cout << "Client socket connected!" << std::endl; 

      thrd = CreateThread(NULL, 0, &Net::Threading, &sock_accept, 0, NULL); 
     } 
    } 

    static void HandleRequest(char response[], int length) 
    { 
     std::cout << std::endl; 

     for(int i = 0; i < length; i++) 
     { 
      std::cout << response[i]; 
     } 

     std::cout << std::endl; 
    } 

    static DWORD WINAPI Threading(LPVOID lpParam) 
    { 
     SOCKET *my_socket = (SOCKET*)lpParam; 

     char data[0x400]; 
     int result = recv((*my_socket), data, sizeof(data), 0); 
     HandleRequest(data, result); 
     char *response = "HTTP/1.1 200 OK\r\nServer: Amegas.sys-IS/1.0\r\nContent-type: text/html\r\nSet-Cookie: ASD643DUQE7423HFDG; path=/\r\nCache-control: private\r\n\r\n<h1>Hello World!</h1>\r\n\r\n"; 
     result = send((*my_socket), response, (int)strlen(response), 0); 

     if(result == SOCKET_ERROR) 
     { 
      std::cout << "Sending data via socket failed with the error: " << WSAGetLastError() << std::endl; 
      closesocket((*my_socket)); 
      WSACleanup(); 
     } 
     else 
     { 
      result = shutdown((*my_socket), 2); 
     } 

     return 0; 
    } 

public: 
    Net(void) 
    { 
     Header *obj_h = new Header(); 

     WSAInit(&obj_h->wsa_data, &obj_h->wsa_version); 

     SocketInit(&obj_h->sock); 
     SocketBind(&obj_h->sock, &obj_h->service); 

     SocketAccept(&obj_h->sock); 

     delete obj_h; 
    } 
} Net; 

int main(void) 
{ 
    Net *obj_net = new Net(); 

    delete obj_net; 

    return 0; 
} 

Answer 1

お使いのOSを受け入れる（）キューイングを処理する - それについてはあまり心配しないでください。シンプル同期サーバは、このように実行する傾向がある：

socket listeningSocket:=socket.create; 
listeningSocket.bind('0.0.0.0',80); // address/port 
listeningSocket.listen; 

while(true){ 
    socket serverClientSocket=accept(listeningSocket); 
    createThread(&serverClientThread,serverClientSocket); 
} 

void serverClientThread(void *param) 
{ 
    inBuffer char[256]; 
    socket myServerClientSocket=(socket)param; 
    while(true){ 
    int bytesRx=recv(myServerClientSocket,&inBuffer,size(inBuffer)); 
    if (bytesRx>0){ 
     if doSomethingWith(&inBuffer,bytesRx) // not necessarily size(inBuffer) bytes!! 
     { 
      send(myServerClientSocket,"Reply from server\r\n"); 
     } 

    } 
    else 
     return; // on error or connection closed 
    } 
} 

1つのリスニングスレッド、（コンソールアプリケーションのメインスレッドをすることができます）、受け入れる（）ループfoerverが実行されます。別のserverClientThreadインスタンスは、クライアントの接続が切断されるか、その他のエラーが発生するまで実行されます。