how to use socket in thread?

Question

I use socket in thread and edit some buffer or std::vector will cause critical error detected c0000374

when I use thread.detach();

yes I use socket to get data in while loop and If I do not do this how to get data ? So I have to use detach(even though I do not want ).

Answer 1

Hi,

For example:
Server:

#include <iostream>
#include <thread>
#include <vector>
#include <cstring>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")  
void handle_client (SOCKET client_socket) {
    int i = 1;
    while (i>0) {
        //char buffer[1024] = { 0 };
        std::vector<char> buffer (1024);
      
         i = recv (client_socket, buffer.data(), sizeof (buffer), 0);
        if (i > 0) {
            std::cout << "Received: " << buffer.data () << std::endl;
          
            const char* message = "Hello from server!";
            send (client_socket, message, strlen (message), 0);
        }
    }
  
    closesocket (client_socket);
}
int main () {
   
    WSADATA wsa_data;
    if (WSAStartup (MAKEWORD (2, 2), &wsa_data) != 0) {
        std::cerr << "WSAStartup failed.\n";
        return 1;
    }
  
    SOCKET server_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (server_socket == INVALID_SOCKET) {
        std::cerr << "Socket creation failed.\n";
        WSACleanup ();
        return 1;
    }
  
    sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;  
    server_addr.sin_port = htons (8080);  
    if (bind (server_socket, (sockaddr*)&server_addr, sizeof (server_addr)) == SOCKET_ERROR) {
        std::cerr << "Bind failed.\n";
        closesocket (server_socket);
        WSACleanup ();
        return 1;
    }
    
    if (listen (server_socket, SOMAXCONN) == SOCKET_ERROR) {
        std::cerr << "Listen failed.\n";
        closesocket (server_socket);
        WSACleanup ();
        return 1;
    }
    std::cout << "Server listening on port 8080...\n";
    std::vector<std::thread> threads;
   
    while (true) {
        sockaddr_in client_addr;
        int client_addr_size = sizeof (client_addr);
        SOCKET client_socket = accept (server_socket, (sockaddr*)&client_addr, &client_addr_size);
        if (client_socket == INVALID_SOCKET) {
            std::cerr << "Accept failed.\n";
            continue;
        }
        std::cout << "Client connected.\n";
       
        threads.emplace_back (handle_client, client_socket);
       
    }
 
    closesocket (server_socket);
    WSACleanup ();
    for (auto& th : threads) {
        if(th.joinable())
        th.detach ();
    }
    
    return 0;
}

Test client:

#include <iostream>
#include <string>
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "Ws2_32.lib")
int main () {
    WSADATA wsaData;
    SOCKET client_socket;
    sockaddr_in server_addr;
    std::string message;
   
    if (WSAStartup (MAKEWORD (2, 2), &wsaData) != 0) {
        std::cerr << "Winsock initialization failed!" << std::endl;
        return 1;
    }
    
    client_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (client_socket == INVALID_SOCKET) {
        std::cerr << "Socket creation failed!" << std::endl;
        WSACleanup ();
        return 1;
    }
    
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons (8080);  
    
    inet_pton (AF_INET, "127.0.0.1", &server_addr.sin_addr);  
    
    if (connect (client_socket, (sockaddr*)&server_addr, sizeof (server_addr)) == SOCKET_ERROR) {
        std::cerr << "Connection to server failed!" << std::endl;
        closesocket (client_socket);
        WSACleanup ();
        return 1;
    }
    std::cout << "Connected to the server!" << std::endl;
    
    while (true) {
        std::cout << "Enter message to send (type 'exit' to quit): ";
        std::getline (std::cin, message);
        
        if (message == "exit") {
            break;
        }
       
        send (client_socket, message.c_str (), message.size (), 0);
       
        char buffer[1024];
        int bytes_received = recv (client_socket, buffer, sizeof (buffer), 0);
        if (bytes_received > 0) {
            std::cout << "Server response: " << std::string (buffer, 0, bytes_received) << std::endl;
        }
    }
   
    closesocket (client_socket);
    WSACleanup ();
    return 0;
}