为什么 QDialog::exec() 会阻止 QTcpSocket 工作

Question

I make a Bomberman (or DynaBlast) game clone with multiplayer. Server game and client game communicate through messages using QTcpSocket. Typical workflow for playing network game is following:

• Server player execs NetworkGame dialog, among other things this dialog creates NetworkGame object
• Client player execs ClientGame dialog, among other things this dialog creates ClientGame object
• Client chooses IP of server and clicks "Connect"
• Server accepts connections, server and clients are now able to send messages each other
• Client sends "ready"-message, server start game
• When game over, the game object emits GameStatusChanged(GameStatus newStatus) signal. This signal connected to MainWindow, which execs GameOverDialog . If player chooses "Play again" at GameOverDialog , MainWindow execs NetworkGame or ClientGame dialogs again and we are at the first points.

So, after first game is over, second exec of ClientGameDialog blocks QTcpSocket work in the way it cann't read data or emit QTcpSocket::readyRead signal (I don't know which one point exactly). ClientGameDialog 's GUI is responsive, it can send messages to server, but it cann't read messages. At the same time NetworkGame and NetworkGameDialog work properly - they are able to send and receive messages. I checked all my classes several times and don't see any significant difference.

I think full code is to huge to post it here, so I gave UML a try. This is a chart for most important classes. Green arrow designates Qt's child-parent relations, starting at a child QObject it points to a parent.

When Socket class receives new message through QTcpSocket interface, it emits messageReceived(const Message& message) signal; other classes can connect to this signal via slots and handle messages. I don't see what Client , ServerWorker , Server classes can do with event loop, the just help to process raw data from QTcpSocket and deliver messages to other classes, particulary to Game and Dialog classes.

Here is some code (I have some code duplications, I leave them until better times). Creating game:

// Server game
void MainWindow::startNetworkGame() // User clicked "Start network game" button
{
    const auto& player = mainMenuWidget_->selectedPlayer();
    gameDialogs_ = createGameDialogs(this, GameType::Server, player);
    auto answer  = gameDialogs_.creationDialog->exec();
    if (answer == QDialog::Accepted) {
        auto initializationData = gameDialogs_.creationDialog->initializationData();
        initializeGame(initializationData);
        startGame(initializationData);
    }
}

// Client game
void MainWindow::connectToServer() // User clicked "Connect to server" button
{
    const auto& player = mainMenuWidget_->selectedPlayer();
    gameDialogs_       = createGameDialogs(this, GameType::Client, player);
    auto answer        = gameDialogs_.creationDialog->exec(); // At first time it works fine
    if (answer == QDialog::Accepted) {
        auto initializationData = gameDialogs_.creationDialog->initializationData();
        initializeGame(initializationData);
        startGame(initializationData);
    }
}

Next snippet is code for processing GameStatusChanged signal when game was over:

void MainWindow::gameStatusChanged(GameStatus newStatus)
{
    if (newStatus == GameStatus::GameOver) {
        auto* gameOverDialog = gameDialogs_.gameOverDialog;
        gameOverDialog->setGameResult(gameData_.game->gameResult());
        auto gameOverDialogAnswer = gameOverDialog->exec();
        if (gameOverDialogAnswer == QDialog::Accepted) {
            gameDialogs_.creationDialog->reset();
            auto answer = gameDialogs_.creationDialog->exec(); // At this point client cann't receive messages, but server can.
            if (answer == QDialog::Accepted) {
                auto initializationData = gameDialogs_.creationDialog->initializationData();
                initializeGame(initializationData);
                startGame(initializationData);
            } else {
                showMainMenu();
            }
        } else {
            showMainMenu();
        }
    }
}

I suspect that ClientGameDialog 's event loop (is it indeed has it's own event loop) doesn't processes QTcpSocket 's events. I tried to replace exec() with open methods for client dialog:

void MainWindow::gameStatusChanged(GameStatus newStatus)
{
    if (newStatus == GameStatus::GameOver) {
        auto* gameOverDialog = gameDialogs_.gameOverDialog;
        gameOverDialog->setGameResult(gameData_.game->gameResult());
        auto gameOverDialogAnswer = gameOverDialog->exec();
        if (gameOverDialogAnswer == QDialog::Accepted) {
            gameDialogs_.creationDialog->reset();
            auto d = qobject_cast<ClientGameDialog*>(gameDialogs_.creationDialog);
            if (d) {
                gameDialogs_.creationDialog->open();
            } else {
                auto answer = gameDialogs_.creationDialog->exec();
                if (answer == QDialog::Accepted) {
                    auto initializationData = gameDialogs_.creationDialog->initializationData();
                    initializeGame(initializationData);
                    startGame(initializationData);
                } else {
                    showMainMenu();
                }
            }
        } else {
            showMainMenu();
        }
    }
}

It works, but I want to find where was the problem. Maybe someone can prompt, where to search a solution. Main questions are: where the difference between Server and Client code flows and why Client code works fine at the first time and breaks at the second.

Answer 1

This is because QDialog::exec is a synchronous blocking operation that will stop the event loop of the main thread and start a new event loop for this dialog. This most of the time is not a problem unless you are doing some continuous work on the main thread such as processing QTCPSocket

Instead of using QDialog::exec use QDialog::open which is asynchronous and does not start a new event loop, you can simply connect signals from the dialog to read the results once the user will accept/close the dialog.

If you require blocking dialogs then you also can simply offload QTcpSocket to another thread and do whole processing asynchronously and only emit required updates to the main GUI thread.