Опция SO_REUSEADDR не работает, когда приложение пытается привязать порт

У меня есть приложение, которое сбрасывается и снова начинает прослушивание, если сокет закрыт удаленно. Поведение, которое я наблюдаю, заключается в том, что при первой загрузке приложение может прослушивать, но когда я пытаюсь очистить и снова начать прослушивание, я получаю ошибку при привязке порта. Для контекста ниже приведены соответствующие методы моего серверного класса.

void Server::listen() {
    std::cout<<"Server::listen\n";
    m_listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (m_listenSocket < 0) {
        std::cout<<"Failed to open listen socket.\n";
        return;
    }
        
    int optval = 0;
    if (setsockopt(m_listenSocket, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
        std::cout<<"Failed to set SO_REUSEADDR option.\n";
        close(m_listenSocket);
        return;
    }
        
    struct sockaddr_in server_addr;
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(m_port);
        
    if (bind(m_listenSocket, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cout<<"Failed to bind to port.\n";
        std::cout<<strerror(errno)<<"\n";
        close(m_listenSocket);
        return;
    }
        
    int backlog = 1;  // We are only interested to pool one client.
    if (::listen(m_listenSocket, backlog) < 0) {
        std::cout<<" Failed to listen on the listen socket.\n";
        close(m_listenSocket);
        return;
    }
        
    std::cout<<"Server is listening."<<":port = "<<m_port<<"\n";
        
    m_acceptThread = std::thread(&SocketServer::acceptThread, this);
}

void Server::cleanup(){
    std::cout<<"Server::cleanup.\n";
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_messageQueue.clear();
        m_sendThreadWait.notify_one();
    }
    ::shutdown(m_listenSocket, SHUT_RD); // socket that is used for listening
    ::shutdown(m_socketId, SHUT_RDWR);// socket that was returned by ::accept
    joinThreads(); // ensures recv/send/accept thread joins and completes
}
    
void Server::resetThread() {
    std::cout<<"Server::resetThread started.\n";
    cleanup();
    {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_startDisconnect = false;
    }
    //sleep(5);<- had no effect
    listen();
    
    std::cout<<"Server::resetThread completed.\n";
}

Результат, который я получаю:

Server:listen
Server:listen::SocketServer is listening.:port=11008
...
Server:recvThread::connection closed by remote.
Server:recvThread::completed
Server:resetThread::started.
Server:cleanup
Server:joinThreads
Server:listen
Server:listen:: Failed to bind to port.
Address already in use
Server:resetThread::completed.

Теперь, как только происходит отключение, мое приложение выполняет сброс и вызывает listen(), который снова пытается подключиться к тому же порту, но я читал, что SO_REUSEADDR сообщает ОС, что приложение может немедленно снова выполнить привязку, это правильное понимание? Если да, то что мне здесь не хватает?

Я также пробовал поставить сон на 5 секунд, но это тоже не помогло. Обратите внимание: если я подожду некоторое время и снова запущу приложение, оно сможет снова привязаться без каких-либо проблем.

Я использую операционную систему Linux.

ОБНОВЛЯТЬ:

Показываю acceptThread и присоединяюсь к теме:

void Server::acceptThread() {
    try {
        std::cout<<"Server::acceptThread::started.\n";
        socklen_t sockaddrLength = sizeof(struct sockaddr_in);
        int incomingSocketId = accept(m_listenSocket, NULL, sockaddrLength);
        if (incomingSocketId < 0) {
            std::cout<<"Failed to accept the client connection\n";
            return;
        }
    
        m_socketId = incomingSocketId;
    
        // Set socket to non-blocking mode
        int flags = fcntl(m_socketId, F_GETFL, 0);
        fcntl(m_socketId, F_SETFL, flags | O_NONBLOCK);
             
        // Start send and recv thread
        m_sendThread = std::thread(&SocketServer::sendThread, this);
        m_recvThread = std::thread(&SocketServer::recvThread, this);
    
    } catch (const std::exception& e) {
        std::cout<<"socket closed by remote."<< e.what()<<"\n";
        return;
    }
    std::cout<<"Server::acceptThread completed.\n";
}

void Server::joinThreads() {
    std::cout<<"Server::joinThreads.\n";
    if (m_acceptThread.joinable()) {
        m_acceptThread.join();
    }
    
    if (m_recvThread.joinable()) {
        m_recvThread.join();
    }
    
    if (m_sendThread.joinable()) {
        m_sendThread.join();
    }
}

Вывод консоли, зависает на accept():

Server:listen
Server:listen::SocketServer is listening.:port=49152
Server:acceptThread::started.
Server:shutdown
Server:joinThreads