Sockets 关于select（）的问题_Sockets_Select_Tcp_Server

Sockets 关于select（）的问题

sockets select tcp server

Sockets 关于select（）的问题,sockets,select,tcp,server,Sockets,Select,Tcp,Server,考虑以下分类方法： void TCPServer::listenWithTimeout() { fd_set descrSet; struct timeval timeout = {1, 0}; while (listeningThread.active) { std::cout << "TCP Server thread is listening..." << std::endl; FD_ZERO(&descrSet); FD

考虑以下分类方法：

void TCPServer::listenWithTimeout() {
  fd_set descrSet;
  struct timeval timeout = {1, 0};
  while (listeningThread.active) {
    std::cout << "TCP Server thread is listening..." << std::endl;
    FD_ZERO(&descrSet);
    FD_SET(mySocketFD, &descrSet);
    int descrAmount = select(mySocketFD + 1, &descrSet, NULL, NULL, &timeout);
    if (descrAmount > 0) {
      assert(FD_ISSET(mySocketFD, &descrSet));
      int threadIndx = findAvailableThread();
      if (threadIndx < 0) {
        std::cout << "Connection not accepted: no threads available..." << std::endl;
      } else {
        joinThread(threadIndx);
        int newSocketFD = accept(mySocketFD, (struct sockaddr *) &mySocket, &clieAddrssLen);
        std::cout << "TCP Client connected..." << std::endl;
        connectionThreads[threadIndx].thread = std::thread(TCPServer::startTCPConnectionWithException, std::ref(*this), threadIndx, newSocketFD);
        connectionThreads[threadIndx].active = true;
      }
    }
  }
  std::cout << "TCP Server thread is terminating..." << std::endl;
}

void TCPServer:：listenWithTimeout（）{
fd_集描述集；
struct timeval timeout={1，0}；
while（listingthread.active）{
标准：：cout
当没有可用的线程时（findAvailableThreads（）返回-1），select（）不等待其超时，因此while循环在新线程可用之前非常快速地迭代，这是正常的行为吗
是的，因为在这种情况下，您没有调用accept（）
，因此您没有更改侦听套接字的状态。只要它有一个客户端连接等待accept（）
，它就会保持可读状态
如果是，我如何避免这些非常快的迭代
在检查可用线程之前调用accept（）
。如果没有可用线程，请关闭已接受的连接
有没有办法让select（）恢复超时，而不是在if分支的第13行使用简单的sleep（）呢
唯一的方法是accept（）
甚至，有没有一种方法可以完全拒绝等待的传入连接
唯一的方法是先accept（）
它，然后如果需要可以close（）
它
试试这个：
void TCPServer::listenWithTimeout() {
    fd_set descrSet;
    while (listeningThread.active) {
        std::cout << "TCP Server thread is listening..." << std::endl;
        FD_ZERO(&descrSet);
        FD_SET(mySocketFD, &descrSet);
        struct timeval timeout = {1, 0};
        int descrAmount = select(mySocketFD + 1, &descrSet, NULL, NULL, &timeout);
        if (descrAmount > 0) {
            assert(FD_ISSET(mySocketFD, &descrSet));
            int newSocketFD = accept(mySocketFD, (struct sockaddr *) &mySocket, &clieAddrssLen);
            if (newSocketFD != -1) {
                int threadIndx = findAvailableThread();
                if (threadIndx < 0) {
                    close(newSocketFD);
                    std::cout << "Connection not accepted: no threads available..." << std::endl;
                } else {
                    joinThread(threadIndx);
                    std::cout << "TCP Client connected..." << std::endl;
                    connectionThreads[threadIndx].thread = std::thread(TCPServer::startTCPConnectionWithException, std::ref(*this), threadIndx, newSocketFD);
                    connectionThreads[threadIndx].active = true;
                }
            }
        }
    }
    std::cout << "TCP Server thread is terminating..." << std::endl;
}

void TCPServer:：listenWithTimeout（）{
fd_集描述集；
while（listingthread.active）{
标准：：cout
当没有可用的线程时（findAvailableThreads（）返回-1），select（）不等待其超时，因此while循环在新线程可用之前非常快速地迭代，这是正常的行为吗
是的，因为在这种情况下，您没有调用accept（）
，因此您没有更改侦听套接字的状态。只要它有一个客户端连接等待accept（）
，它就会保持可读状态
如果是，我如何避免这些非常快的迭代
在检查可用线程之前调用accept（）
。如果没有可用线程，请关闭已接受的连接
有没有办法让select（）恢复超时，而不是在if分支的第13行使用简单的sleep（）呢
唯一的方法是accept（）
甚至，有没有一种方法可以完全拒绝等待的传入连接
唯一的方法是先accept（）
它，然后如果需要可以close（）
它
试试这个：
void TCPServer::listenWithTimeout() {
    fd_set descrSet;
    while (listeningThread.active) {
        std::cout << "TCP Server thread is listening..." << std::endl;
        FD_ZERO(&descrSet);
        FD_SET(mySocketFD, &descrSet);
        struct timeval timeout = {1, 0};
        int descrAmount = select(mySocketFD + 1, &descrSet, NULL, NULL, &timeout);
        if (descrAmount > 0) {
            assert(FD_ISSET(mySocketFD, &descrSet));
            int newSocketFD = accept(mySocketFD, (struct sockaddr *) &mySocket, &clieAddrssLen);
            if (newSocketFD != -1) {
                int threadIndx = findAvailableThread();
                if (threadIndx < 0) {
                    close(newSocketFD);
                    std::cout << "Connection not accepted: no threads available..." << std::endl;
                } else {
                    joinThread(threadIndx);
                    std::cout << "TCP Client connected..." << std::endl;
                    connectionThreads[threadIndx].thread = std::thread(TCPServer::startTCPConnectionWithException, std::ref(*this), threadIndx, newSocketFD);
                    connectionThreads[threadIndx].active = true;
                }
            }
        }
    }
    std::cout << "TCP Server thread is terminating..." << std::endl;
}

void TCPServer:：listenWithTimeout（）{
fd_集描述集；
while（listingthread.active）{
std:：coutint侦听（int s，int backlog）
，而不是在连接后立即接受和关闭，限制backlog
参数可能是另一种解决方案？另一种可能的处理方法是在descrSet
中不包括accept套接字，如果您知道当前没有任何线程可用于处理下一个传入的连接——这将防止您的select（）
调用在无法处理新连接时返回（当然，当线程可用时，您需要有某种方法从select（）
唤醒，以便您可以在此时再次开始查看accept套接字）考虑int listen（int s，int backlog）
，而不是在连接后立即接受和关闭，限制backlog
参数可能是另一种解决方案？另一种可能的处理方法是在descrSet
中不包括accept套接字，如果您知道当前没有任何线程可用于处理下一个传入的连接——这将阻止您的select（）
调用在无法处理新连接时返回。（当然，当线程可用时，您需要有某种方法从select（）
唤醒，以便您可以在此时再次开始查看accept套接字）