我熟悉 pthreads，但不熟悉 Windows 线程。在 Linux 中，一个新线程可以这样启动:

pthread_t tid;
int rc = pthread_create(&tid, NULL, Threadfn, &newsocket);
assert (rc == 0);
//<snip>//

和Threadfn可以轻松重构Socket:

void *Threadfn(void *vargp){
    pthread_detach(pthread_self());
    int *Socket = (int *) vargp;
    print("Socket is %d\n", *Socket);
    // recv/read/send etc.. 
    pthread_exit(NULL);
}

我们如何在 Windows 线程中执行此操作？

我创建线程:

HANDLE thread = CreateThread(NULL, 0, Somethready, &ClientSocket, 0, NULL);

但我似乎在使用 Somethready 时遇到了麻烦:

DWORD WINAPI Somethready(void *vargp) {
    printf("Thread got evoked\n");
    SOCKET *clientSocket = (SOCKET *)vargp;
    SOCKET ClientSocket = *clientSocket;
    printf("In thread, ClientSocket: %d\n", ClientSocket);
    /*
    char RecvBuf[bufsize];
    memset(RecvBuf, 0, bufsize);
    int n = recv(ClientSocket, RecvBuf, bufsize,0);
    print("We got %d bytes, we got %s\n", n, RecvBuf);
    */
    return 0;
}

我似乎无法正确理解:

ClientSocket: 184
Thread got evoked
In thread, ClientSocket: -1 // <<-- this 

我做错了什么？ IOW，我怎样才能正确地将 ClientSocket 传递给 Windows 线程？

谢谢!

编辑 1

ClientSocket 是这样形成的:

while (1) {
    SOCKET ClientSocket = INVALID_SOCKET;
    ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    printf("ClientSocket: %d\n", ClientSocket);
    HANDLE thread = CreateThread(NULL, 0, Somethready, &ClientSocket, 0, NULL);
}

编辑2

感谢您的回复。我有点动摇，因为我以前从未在 Linux 中遇到过这种情况 - 不知何故，变量不会那么快消失，至少在我尝试时是这样。然而，这在我第一次尝试 Windows 线程时就渗透了。这是一个宝贵的教训。

问题: 我注意到，如果我在调用线程后立即添加一个轻微的延迟(如下所示)，它似乎表现正常，但我们没有有一个堆分配以便稍后清理，这使它更具吸引力。我很好奇这是否可以接受，或者这是一场等待中的灾难。谢谢!

while (1) {
    SOCKET ClientSocket = INVALID_SOCKET;
    ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    printf("ClientSocket: %d\n", ClientSocket);
    HANDLE thread = CreateThread(NULL, 0, Somethready, &ClientSocket, 0, NULL);
    Sleep(30); // < -- this 
}

最佳答案

发布的 Windows 代码和发布的 Linux 代码中的一个问题是，您传递给新生成的线程的参数是指向父线程堆栈上局部变量的指针，并且该局部变量可能在子线程有机会开始运行并查看它之前，已经从堆栈中弹出(因此可能被其他一些数据覆盖)。

因此，解决问题的方法就是保证子线程看数据的时候数据仍然有效。您可以通过多种方式执行此操作:

1) 简单(通常也是最好)的方法:不是在堆栈上分配套接字(作为局部变量)，而是从堆中分配它:

// main thread
while (1) {
    SOCKET * pClientSocket = (SOCKET *) (malloc(sizeof(SOCKET)));  // allocate a SOCKET on the heap
    if (pClientSocket == NULL) {printf("malloc() failed!?\n"); break;}

    *pClientSocket = accept(ListenSocket, NULL, NULL);
    if (*pClientSocket == INVALID_SOCKET) {
        free(pClientSocket);  // avoid memory leak!
        printf("accept failed: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    printf("ClientSocket: %d\n", *pClientSocket);
    HANDLE thread = CreateThread(NULL, 0, Somethready, pClientSocket, 0, NULL);
    if (thread == NULL)
    {
       closesocket(*pClientSocket);  // avoid socket leak!
       free(pClientSocket);  // avoid memory leak!
       printf("CreateThread failed!?\n");
    }
}

// child thread
DWORD WINAPI Somethready(void *vargp) {
    printf("Thread got evoked\n");
    SOCKET *pClientSocket = (SOCKET *)vargp;
    SOCKET ClientSocket   = *pClientSocket;  // make a copy of the heap-allocated SOCKET object into a local variable
    free(pClientSocket);                     // then free the heap-allocated SOCKET to avoid a memory leak

    printf("In thread, ClientSocket: %d\n", ClientSocket);
    [...]

    closesocket(ClientSocket);  // don't forget to close the socket when we're done
    return 0;
}

这会很好地工作，因为堆分配的 SOCKET 对象(由 pClientSocket 指向)保证不会被销毁，直到有人调用 free() ，在将其内容复制到局部变量 ClientSocket 之后，此代码将其留给子线程执行。

唯一潜在的陷阱是，如果您忘记在堆分配的套接字上调用 free()(例如，在错误处理提前返回的情况下)，很容易意外地造成内存泄漏), 所以你需要小心。

2) 廉价黑客方式。这涉及一些潜在的不安全/未定义行为调用转换，但它在实践中有效，所以很多人都这样做。在这种方法中，我们只是将 SOCKET 的值直接填充到 void-pointer 中。我不推荐它，但为了完整性:

// main thread
while (1) {
    SOCKET ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    printf("ClientSocket: %d\n", *ClientSocket);
    HANDLE thread = CreateThread(NULL, 0, Somethready, (void *) ClientSocket, 0, NULL);
    if (thread == NULL)
    {
       closesocket(ClientSocket);  // avoid socket leak
       printf("CreateThread failed!?\n");
    }
}

// child thread
DWORD WINAPI Somethready(void *vargp) {
    printf("Thread got evoked\n");
    SOCKET ClientSocket = (SOCKET)vargp;  

    printf("In thread, ClientSocket: %d\n", ClientSocket);
    [...]

    closesocket(ClientSocket);  // don't forget to close the socket itself when we're done
    return 0;
}

3) 我太聪明了，一个程序员不适合我自己的好方法:在这种方法中，在生成子线程之后，我们使用一个条件变量来阻止主线程的执行，直到子线程表明它已经开始运行并且不再使用指向主线程的堆栈变量的指针。我打算用伪代码写这个，因为我不是在 Windows 机器上测试它，但这应该给你一个大概的想法:

// global variables (or if you don't like global variables, you 
// could put these into a struct, along with the SOCKET object, 
// and pass a pointer-to-the-struct to the child thread instead)
CONDITION_VARIABLE wait_for_child_thread;
CRITICAL_SECTION   critical_section;

InitializeCriticalSection(&critical_section);
InitializeConditionVariable(&wait_for_child_thread);

// main thread
while (1) {
    SOCKET ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
        printf("accept failed: %d\n", WSAGetLastError());
        closesocket(ListenSocket);
        WSACleanup();
        return 1;
    }
    printf("ClientSocket: %d\n", *ClientSocket);
    HANDLE thread = CreateThread(NULL, 0, Somethready, &ClientSocket, 0, NULL);
    if (thread != NULL)
    {  
       // Gotta wait here until the child thread wakes us up,
       // otherwise we risk invalidating (&ClientSocket) before he has used it!
       EnterCriticalSection(&critical_section);
       SleepConditionVariableCS(&wait_for_child_thread, &critical_section, INFINITE);
       LeaveCriticalSection(&critical_section);
    }
    else
    {  
       printf("CreateThread failed!?\n");
    }
}

// child thread
DWORD WINAPI Somethready(void *vargp) {
    printf("Thread got evoked\n");
    SOCKET * pClientSocket = (SOCKET *)vargp;
    SOCKET ClientSocket    = *pClientSocket;  // copy from main-thread's stack to our own stack

    // Now that we've made the copy, tell the main thread he can continue execution
    WakeConditionVariable(&wait_for_child_thread);

    printf("In thread, ClientSocket: %d\n", ClientSocket);
    [...]

    closesocket(ClientSocket);  // don't forget to close the socket itself when we're done
    return 0;
}

关于c - Windows线程接受套接字上的连接，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56052469/