tcp 服务器的奇怪行为（使用 winsock）

Question

我正在为 tcp 服务器使用 winsock 和 c++ 11 线程。对于每个客户端，我创建一个新的 ReceiveThread 对象，它有一个 std::thread 对象。 Tcp 客户端位于 Java。我想创建一个简单的广播功能。（如果有人发送消息，则服务器将其转发给所有人）。我为客户端套接字使用包装器 class，其中包括互斥体。（同步 unordered_map）。每条消息都是结构化的。第一个字节是消息的长度，第二个字节表示类型，然后是实际数据。（数据长度已知，第一个字节是那个）

[编辑] 我现有的代码适用于一个客户。当第二个客户端连接时，他也可以发送消息，并且两个客户端都收到了。但是如果我用第一个客户端发送一条消息，服务器会在属于第二个客户端的第二个线程上接收它（消息正确到达）。在此之后，服务器不会从第一个客户端收到任何东西。（我去掉了'send forward to everybody'部分，因为问题出现在接收部分，我也编辑了void ReceiveThread::receive()，现在只调用一次，稍后再处理）

Server.cpp

#include "Server.h"
#include <thread>
#include <string>
#include <winsock2.h>
#include <iostream>
#include "ReceiveThread.h"


using namespace std;

Server::Server(string ip, int port):ip(ip),port(port){
    init();
}

int Server::init(){

    //init the winsock library
    WSADATA wsaData;
    int iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != NO_ERROR){
        cout << "Error WSAStartup!";
        return -1;
    }

    // Create a SOCKET for listening for incoming connection requests.
    listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listenSocket == INVALID_SOCKET) {
        cout << "Error at socket(): " << WSAGetLastError();
        WSACleanup();
        return -1;
    }

    //----------------------
    // The sockaddr_in structure specifies the address family,
    // IP address, and port for the socket that is being bound.
    sockaddr_in service;
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(ip.c_str());
    service.sin_port = htons(port);

    if ( ::bind(listenSocket, (SOCKADDR*)&service, sizeof(service)) == SOCKET_ERROR) {
        cout << "Bind error.";
        closesocket(listenSocket);
        WSACleanup();
        return -1;
    }

    //----------------------
    // Listen for incoming connection requests.
    // on the created socket
    if (listen(listenSocket, 1) == SOCKET_ERROR) {
        cout << "Error listening on socket.\n";
        closesocket(listenSocket);
        WSACleanup();
        return -1;
    }

    // Accept connections
    acceptConnections();

}
void Server::acceptConnections(){
    // Create a SOCKET for accepting incoming request.
    SOCKET acceptSocket;
    cout << "Waiting for clients.";
    int counter = 0;
    while (1){
        acceptSocket = accept(listenSocket, NULL, NULL);
        if (acceptSocket == INVALID_SOCKET){
            cout << "Accept error";
            closesocket(listenSocket);
            WSACleanup();
            return;
        }
        else{
            clientSockets.add(acceptSocket);
            cout << "Client connected.";
            // create a new receive thread object for every client
            counter++;
            ReceiveThread receiveThread(clientSockets, acceptSocket,counter);
        }
    }
}

ReceiveThread.cpp

#include "ReceiveThread.h"
#include <winsock2.h>
#include "Message.h"
#include <iostream>
#include <string>

using namespace std;

ReceiveThread::ReceiveThread(ClientSockList &clients, SOCKET &socket,int counter) :clients(clients), socket(socket),counter(counter){
    //cout << clients.getList().size();
    receiveThread = new thread(&ReceiveThread::receive, this);
}

void ReceiveThread::terminateThread(){
    terminated = true;
}
void ReceiveThread::receive(){
    int res;
    while (!terminated){

        char recvbuf[BUF_SIZE]; // BU_SIZE = 1024
        int recv_len = 0;
        res = recv(socket, recvbuf + recv_len, BUF_SIZE - recv_len, 0);
        if (!checkSocket(res)) break;
        cout << "[" << counter << "] ";
        for (int i = 0; i < res; ++i){
            cout << recvbuf[i];
        }
        cout << endl;
    }
    //delete receiveThread;
}

bool ReceiveThread::checkSocket(int res){
    if (res == SOCKET_ERROR || res == 0){
        terminated = true;
        cout << endl << "Terminated" << endl;
        clients.remove(socket);
        closesocket(socket);
        return false;
    }
    else{
        return true;
    }
}

这是我从客户端发送消息的方式：

public void sendMessageForBroadcast(String message) throws IOException {
    //String m = buildMessage(message,Message.TYPE_BROADCAST);
    StringBuffer buff = new StringBuffer();
    buff.append(Character.toChars(message.length()));
    buff.append(Character.toChars(1));
    buff.append(message);

    //System.out.println("Sending message: " + m + "["+m.length()+"]");
    outputStream.write(buff.toString().getBytes("UTF8"));
    outputStream.flush();
}

[编辑] 场景：

连接客户端1
向客户端1发送消息
在服务器上接收消息（线程 1）
连接客户端2
用客户端2发送消息
在服务器上接收消息（线程 2）
向客户端1发送消息
在服务器上接收消息 （线程 2）
从现在开始，服务器不会从 client1 收到任何东西

Answer 1

你的情况很严重undefined behavior。

一切都从这一行开始：

ReceiveThread receiveThread(clientSockets, acceptSocket,counter);

这将创建一个 ReceiveThread 对象（其构造函数创建您的线程引用 this）。问题是一旦声明完成，声明变量的代码块就结束了，这使得变量超出范围并破坏了对象。

一旦对象被销毁，任何取消引用先前对象this指针的代码（即所有使用对象非静态成员变量或函数的代码）将取消引用已销毁对象的指针，导致说未定义的行为。

我建议您保留一个指向线程对象的指针集合，既可以在需要销毁对象之前将该对象保留在范围内，又可以在您以后需要从其他线程使用它时保留对该对象的引用.

还有另一个可能的来源未定义行为，因为我没有看到你初始化成员变量terminated，这意味着它的值在你引用时是不确定的它在线程中。

tcp 服务器的奇怪行为（使用 winsock）

weird behavior of tcp server (using winsock)

c++

java

sockets

multithreading

tcp