Qtソケット切断のベストプラクティス：waitForDisconnected()の落とし穴と非同期処理

2025-05-27

`bool QAbstractSocket::waitForDisconnected(int msecs = 30000)` とは

この関数は、QAbstractSocket クラス（ネットワークソケットの抽象基底クラス）のメンバー関数であり、ソケットがサーバーから切断されるのを待機するために使用されます。

通常、Qtアプリケーションはイベントループによって駆動され、非同期に動作します。つまり、ネットワーク操作（接続、データの送受信、切断など）は、イベントが発生したときにシグナルが発せられ、それに対応するスロットが呼び出されることで処理されます。しかし、waitForDisconnected() のような waitFor... 系関数は、呼び出し元のスレッドをブロックし、同期的に処理が完了するのを待機するという点で、非同期処理とは異なります。

戻り値:
- ソケットが切断された場合、true を返します。
- タイムアウトした場合、または別のエラーが発生した場合、false を返します。
タイムアウト:
- msecs パラメータで待機するミリ秒数を指定します。デフォルトは30000ミリ秒（30秒）です。
- もしタイムアウトに -1 を指定すると、タイムアウトせずに無限に切断を待ち続けます。
即時リターン: もし関数が呼び出された時点でソケットがすでに切断状態にある場合（UnconnectedStateなど）、この関数はすぐに true を返してブロックせずに終了します。
ソケットの切断待機: ソケットがサーバーから切断されるまで、または指定されたタイムアウト時間（msecs）が経過するまで、呼び出し元のスレッドをブロックします。

使用目的

waitForDisconnected() は主に以下のような状況で使用されます。

ブロッキングソケット操作: イベントループを使用しない、または特定の操作で一時的にブロッキング動作が必要な場合（例えば、アプリケーション終了時のクリーンアップ処理など）。
テストコード: ネットワーク処理が完了したことを同期的に確認したいテストケースで。
シンプルなスクリプト: イベントループを構築するのが面倒なシンプルなスクリプトなど。

注意点

disconnectFromHost() との関連: 通常、ソケットの切断は disconnectFromHost() を呼び出すことで開始されます。waitForDisconnected() はその disconnectFromHost() の結果として disconnected() シグナルが発せられるのを待ちます。disconnectFromHost() は、送信バッファに保留中のデータがある場合、すぐにソケットを閉じずに、すべてのデータが書き込まれるまで待機してから切断処理を行います。
リソースリークの可能性: タイムアウトしない設定 (-1) で使用すると、ソケットが切断されない限り永久にブロックされ、アプリケーションが応答しなくなる可能性があります。適切なタイムアウトを設定することが重要です。
GUIアプリケーションでの使用は避ける: waitForDisconnected() は呼び出し元のスレッドをブロックするため、メイン（GUI）スレッドでこの関数を呼び出すと、アプリケーションがフリーズ（固まる）してユーザーインターフェースが応答しなくなります。GUIアプリケーションでネットワーク操作を行う場合は、QAbstractSocket のシグナル（disconnected() など）とスロットを組み合わせて非同期に処理するか、別のスレッドでブロッキング操作を実行することを強く推奨します。

#include <QTcpSocket>
#include <QDebug>
#include <QCoreApplication> // イベントループを使用しないシンプルな例のため

int main(int argc, char *argv[])
{
    // 通常はQApplicationを使用しますが、ここでは簡単な例としてQCoreApplicationを使用
    QCoreApplication app(argc, argv); 

    QTcpSocket socket;

    // サーバーに接続する（この例では架空のIPアドレスとポート）
    socket.connectToHost("127.0.0.1", 12345);

    // 接続されるのを待機
    if (!socket.waitForConnected(5000)) { // 5秒待機
        qDebug() << "接続に失敗しました:" << socket.errorString();
        return 1;
    }

    qDebug() << "サーバーに接続しました。";

    // ... ここでデータの送受信を行う ...
    socket.write("Hello, server!");
    socket.waitForBytesWritten(1000); // データが書き込まれるのを待機

    // サーバーから切断を開始
    socket.disconnectFromHost();

    // 切断されるのを待機
    // メインスレッドでこれを実行すると、GUIアプリならフリーズします。
    if (socket.waitForDisconnected(3000)) { // 3秒待機
        qDebug() << "サーバーから切断されました。";
    } else {
        qDebug() << "サーバーからの切断にタイムアウトしました:" << socket.errorString();
    }

    return 0; // QCoreApplication::exec() を呼び出さないため、すぐに終了
}

重要な注意
上記の例は waitForDisconnected() の動作を示すためのものであり、**実際のGUIアプリケーションでは、メインスレッドでこのようなブロッキング関数を使用すべきではありません。**代わりに、disconnected() シグナルを捕捉して適切なスロットで処理するように設計してください。

メイン（GUI）スレッドのフリーズ / アプリケーションの応答停止

エラー
最も一般的で深刻なエラーです。GUIアプリケーションのメインスレッドで waitForDisconnected() を呼び出すと、そのスレッドがブロックされ、ユーザーインターフェースが完全にフリーズして応答しなくなります。

原因
Qt のGUIアプリケーションは、イベントループによって駆動されます。UIイベント（ボタンクリック、ウィンドウのリサイズなど）やネットワークイベント（ソケットの接続、データ受信など）は、このイベントループで処理されます。waitForDisconnected() は、その名の通り、切断が完了するまでイベントループをブロックするため、他のすべてのイベント処理が停止します。

トラブルシューティング

非同期処理への切り替え

ブロッキングを避け、Qt のシグナル＆スロットメカニズムを最大限に活用するのが、Qt の推奨するスタイルです。
disconnectFromHost() を呼び出した後、QAbstractSocket::disconnected() シグナルにスロットを接続し、切断完了時の処理はそのスロット内で実装します。

例:

// MySocketHandler.h
class MySocketHandler : public QObject
{
    Q_OBJECT
public:
    MySocketHandler(QObject* parent = nullptr) : QObject(parent) {
        connect(&m_socket, &QTcpSocket::disconnected, this, &MySocketHandler::onDisconnected);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
                this, &MySocketHandler::onError);
    }

    void initiateDisconnect() {
        m_socket.disconnectFromHost();
        qDebug() << "切断処理を開始しました...";
    }

private slots:
    void onDisconnected() {
        qDebug() << "ソケットが切断されました！";
        // 切断後の処理
    }

    void onError(QAbstractSocket::SocketError socketError) {
        qDebug() << "ソケットエラー:" << socketError << m_socket.errorString();
    }

private:
    QTcpSocket m_socket;
};

別スレッドでの実行

waitForDisconnected() のようなブロッキング関数は、常にメインスレッド以外のワーカースレッド（QThread など）で実行するべきです。
ワーカースレッドでソケット操作を行い、切断が完了したら、disconnected() シグナルなどを介してメインスレッドに通知します。

例:

// MyWorkerThread.h
class MyWorkerThread : public QThread
{
    Q_OBJECT
public:
    void run() override {
        QTcpSocket socket;
        // ... 接続処理など ...
        socket.disconnectFromHost();
        if (socket.waitForDisconnected(3000)) {
            emit disconnectedSuccessfully();
        } else {
            emit disconnectedFailed(socket.errorString());
        }
    }
signals:
    void disconnectedSuccessfully();
    void disconnectedFailed(const QString& error);
};

// メインスレッド（例: ウィジェットのコンストラクタやスロット内）
// ...
MyWorkerThread* workerThread = new MyWorkerThread();
connect(workerThread, &MyWorkerThread::disconnectedSuccessfully, this, [](){
    qDebug() << "切断完了！";
    // GUIの更新など
});
connect(workerThread, &MyWorkerThread::disconnectedFailed, this, [](const QString& error){
    qDebug() << "切断失敗:" << error;
    // エラー表示など
});
workerThread->start(); // スレッドを開始

予期せぬタイムアウト / false が返される

エラー
waitForDisconnected() が期待通りに true を返さず、タイムアウトして false を返すことがあります。

原因

切断処理の競合
disconnectFromHost() を呼び出す前に、または呼び出しとほぼ同時にソケットがすでに切断されている場合（例: サーバー側が先に切断した場合）、waitForDisconnected() はすぐに true を返しますが、タイムアウトと誤認する可能性もゼロではありません。
ネットワークの問題
ネットワークケーブルの抜き差し、Wi-Fi接続の切断など、物理的な問題により切断イベントが正常に伝わらないことがあります。
サーバーが接続を閉じない
サーバー側が何らかの理由で接続を正常に閉じない場合、クライアント側は切断されたことを検出できず、タイムアウトします。
タイムアウト時間の不足
ネットワークの状態やサーバー側の応答速度によっては、デフォルトの30秒（または指定した時間）では切断処理が完了しない場合があります。

トラブルシューティング

state() の確認
waitForDisconnected() を呼び出す前と後に socket.state() を確認し、ソケットの状態がどのように変化しているか（ConnectedState から ClosingState、そして UnconnectedState へ）を追跡します。
QAbstractSocket::error() の確認
waitForDisconnected() が false を返した場合、socket.error() と socket.errorString() を呼び出して、具体的なエラー情報を取得します。これにより、切断できなかった原因（例: RemoteHostClosedError が発生していなかったかなど）を特定できます。
ネットワーク診断
クライアントとサーバー間のネットワーク接続に問題がないか、PingやTracerouteなどで確認します。
サーバー側のログ確認
サーバー側が正常に接続を閉じているか、エラーが発生していないかを確認します。

タイムアウト時間の延長
まずは msecs パラメータを増やして、十分な待機時間を与えることを試します。

if (!socket.waitForDisconnected(10000)) { // 10秒に延長
    qDebug() << "切断タイムアウト:" << socket.errorString();
}

waitForDisconnected() を呼び出す前のソケットの状態

エラー
waitForDisconnected() を呼び出す時点でソケットがすでに切断されているのに、何らかの理由でエラーハンドリングが適切に行われない。

原因
waitForDisconnected() は、呼び出し時にソケットが UnconnectedState である場合、すぐに true を返します。これは正常な動作ですが、コードがそのシナリオを適切に処理しない場合に混乱を招く可能性があります。

トラブルシューティング

disconnectFromHost() の呼び出し忘れ
waitForDisconnected() は、ソケットが切断処理を開始していることを前提としています。disconnectFromHost() を呼び出さずに waitForDisconnected() を呼び出しても、ソケットが切断イベントを生成しないため、タイムアウトします。

呼び出し前の状態チェック
waitForDisconnected() を呼び出す前に socket.state() を確認し、ソケットがすでに切断されていないかを明示的にチェックします。

if (socket.state() == QAbstractSocket::UnconnectedState) {
    qDebug() << "ソケットはすでに切断されています。";
} else {
    socket.disconnectFromHost();
    if (socket.waitForDisconnected(3000)) {
        qDebug() << "サーバーから切断されました。";
    } else {
        qDebug() << "切断タイムアウト:" << socket.errorString();
    }
}

QAbstractSocket::abort() との混同

エラー
disconnectFromHost() の代わりに abort() を使用した後で waitForDisconnected() を呼び出す。

原因

abort(): 保留中のデータを破棄し、即座に接続を強制終了します。この場合、disconnected() シグナルが発せられる前にソケットの状態が UnconnectedState になることがあり、waitForDisconnected() の動作が期待通りにならない場合があります。abort() は緊急の場合にのみ使用し、通常は disconnectFromHost() を使用すべきです。
disconnectFromHost(): 保留中のデータをすべて書き込んでから、正常に接続を閉じます。この後、disconnected() シグナルが発せられ、waitForDisconnected() が正常に動作します。

abort() 後の状態確認
もし abort() を使用する必要がある場合、waitForDisconnected() を呼び出すのではなく、直接 socket.state() == QAbstractSocket::UnconnectedState を確認するか、disconnected() シグナルを待ちます。
disconnectFromHost() の使用
正常な切断処理を行う場合は disconnectFromHost() を使用します。

waitForDisconnected() は、その名前が示す通り、ソケットが切断されるのを待機するブロッキング関数です。この関数の性質上、GUIアプリケーションのメインスレッドで直接使用すると、アプリケーションがフリーズする原因となるため、推奨されません。 一般的には、非同期のシグナル＆スロットメカニズムを使用するか、別のスレッドで実行する必要があります。

ここでは、waitForDisconnected() の使用シナリオをいくつか示しますが、特にGUIアプリケーションでの使用においては、その影響を十分に理解し、注意深く実装する必要があります。

例1：非GUIアプリケーション（コンソールアプリなど）でのシンプルな使用

この例では、GUIイベントループがないシンプルなコンソールアプリケーションで waitForDisconnected() を使用します。これは、スクリプトやバックグラウンド処理で一時的なブロッキングが必要な場合に有効です。

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>
#include <QHostAddress>

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv); // GUIなしのイベントループ

    QTcpSocket socket;
    QString serverAddress = "127.0.0.1"; // ローカルホスト
    quint16 serverPort = 12345;         // 適当なポート番号

    qDebug() << "サーバー" << serverAddress << ":" << serverPort << "に接続を試みます...";

    // サーバーに接続
    socket.connectToHost(serverAddress, serverPort);

    // 接続が確立されるのを最大5秒待機
    if (!socket.waitForConnected(5000)) {
        qDebug() << "接続に失敗しました:" << socket.errorString();
        return 1; // 接続失敗で終了
    }

    qDebug() << "サーバーに接続しました！";

    // データ送信（例）
    QByteArray dataToSend = "Hello, server! Please disconnect me.";
    socket.write(dataToSend);
    socket.waitForBytesWritten(1000); // データが書き込まれるのを最大1秒待機

    qDebug() << "データを送信しました。切断を開始します...";

    // サーバーからの切断を要求
    socket.disconnectFromHost();

    // ソケットが切断されるのを最大3秒待機
    if (socket.waitForDisconnected(3000)) {
        qDebug() << "サーバーから正常に切断されました。";
    } else {
        qDebug() << "切断に失敗またはタイムアウトしました:" << socket.errorString();
        // タイムアウトした場合でも、現在のソケットの状態を確認
        qDebug() << "現在のソケットの状態:" << socket.state();
    }

    return 0; // アプリケーション終了
}

コンパイルと実行のヒント

実行
このコードをテストするには、簡単なTCPサーバー（PythonやNetcatなど）を起動し、ポート12345で接続を受け付けるようにする必要があります。
- 例 (Python 3): python -c "import socket; s = socket.socket(socket.AF_INET, socket.SOCK_STREAM); s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1); s.bind(('127.0.0.1', 12345)); s.listen(1); conn, addr = s.accept(); print(f'Connected by {addr}'); data = conn.recv(1024); print(f'Received: {data.decode()}'); conn.close();"
Proファイル
QT += core network を追加

例2：ワーカースレッドでの `waitForDisconnected()` の使用 (GUIアプリケーション向け)

この方法は、GUIアプリケーションでブロッキング操作を実行するための推奨されるアプローチです。QThread を使用して、ソケット操作を別のスレッドにオフロードします。これにより、メインスレッド（GUIスレッド）がブロックされるのを防ぎ、アプリケーションの応答性を維持できます。

`TcpClientWorker.h` (ワーカースレッドで実行されるオブジェクト)

#ifndef TCPCLIENTWORKER_H
#define TCPCLIENTWORKER_H

#include <QObject>
#include <QTcpSocket>
#include <QThread>
#include <QDebug>

class TcpClientWorker : public QObject
{
    Q_OBJECT
public:
    explicit TcpClientWorker(QObject *parent = nullptr);
    ~TcpClientWorker();

public slots:
    void doConnectAndDisconnect(const QString& host, quint16 port);

signals:
    void connectionSuccess();
    void connectionFailed(const QString& error);
    void disconnectedSuccess();
    void disconnectedFailed(const QString& error);

private:
    QTcpSocket m_socket;
};

#endif // TCPCLIENTWORKER_H

`TcpClientWorker.cpp`

#include "TcpClientWorker.h"

TcpClientWorker::TcpClientWorker(QObject *parent) : QObject(parent)
{
    // ソケットはワーカースレッドに移動されるため、親を持たないようにするか、
    // 親がnullptrであることを確認してください。
}

TcpClientWorker::~TcpClientWorker()
{
    if (m_socket.state() != QAbstractSocket::UnconnectedState) {
        m_socket.abort(); // 強制終了
    }
    qDebug() << "Worker destroyed.";
}

void TcpClientWorker::doConnectAndDisconnect(const QString& host, quint16 port)
{
    qDebug() << "Worker thread:" << QThread::currentThreadId() << " - Connecting to" << host << ":" << port;

    m_socket.connectToHost(host, port);

    if (!m_socket.waitForConnected(5000)) {
        emit connectionFailed(m_socket.errorString());
        return;
    }

    emit connectionSuccess();
    qDebug() << "Worker thread: Connected.";

    // ここでデータの送受信を行う
    QByteArray data = "Disconnect me please!";
    m_socket.write(data);
    m_socket.waitForBytesWritten(1000);
    qDebug() << "Worker thread: Data sent.";

    // 切断を開始
    m_socket.disconnectFromHost();
    qDebug() << "Worker thread: Disconnect initiated.";

    // 切断されるのを待機
    if (m_socket.waitForDisconnected(3000)) {
        emit disconnectedSuccess();
        qDebug() << "Worker thread: Disconnected successfully.";
    } else {
        emit disconnectedFailed(m_socket.errorString());
        qDebug() << "Worker thread: Disconnect failed or timed out:" << m_socket.errorString();
    }

    // QObject::deleteLater() を使ってスレッド終了時にオブジェクトを安全に削除
    // これは、スレッドが終了したことを示すシグナルを発行するために便利です。
    // thread->quit(); の後に thread->wait(); が続くことを想定。
    this->deleteLater();
}

`MainWindow.h` (GUIの例)

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QPushButton>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QWidget>
#include <QThread> // QThread をインクルード
#include "TcpClientWorker.h" // ワーカースレッドのクラスをインクルード

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void onConnectAndDisconnectButtonClicked();
    void onConnectionSuccess();
    void onConnectionFailed(const QString& error);
    void onDisconnectedSuccess();
    void onDisconnectedFailed(const QString& error);
    void onWorkerFinished(); // スレッドが終了したときに呼ばれるスロット

private:
    QPushButton *m_connectButton;
    QTextEdit *m_logTextEdit;
    QThread *m_workerThread;
    TcpClientWorker *m_worker;

    void log(const QString& message);
};

#endif // MAINWINDOW_H

`MainWindow.cpp`

#include "MainWindow.h"
#include <QApplication> // main関数に必要

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    setWindowTitle("waitForDisconnected Demo (Worker Thread)");

    QWidget *centralWidget = new QWidget(this);
    QVBoxLayout *layout = new QVBoxLayout(centralWidget);

    m_connectButton = new QPushButton("Connect and Disconnect (Blocking)");
    layout->addWidget(m_connectButton);

    m_logTextEdit = new QTextEdit();
    m_logTextEdit->setReadOnly(true);
    layout->addWidget(m_logTextEdit);

    setCentralWidget(centralWidget);

    connect(m_connectButton, &QPushButton::clicked, this, &MainWindow::onConnectAndDisconnectButtonClicked);

    log("アプリケーション起動。");
}

MainWindow::~MainWindow()
{
    // スレッドがまだ動いている場合は、安全に終了させる
    if (m_workerThread && m_workerThread->isRunning()) {
        m_workerThread->quit();
        m_workerThread->wait(1000); // 最大1秒待機
        if (m_workerThread->isRunning()) {
            m_workerThread->terminate(); // タイムアウトしたら強制終了
            m_workerThread->wait();
        }
    }
    delete m_workerThread; // QObject::deleteLater()でワーカーは削除される
}

void MainWindow::onConnectAndDisconnectButtonClicked()
{
    m_connectButton->setEnabled(false);
    m_logTextEdit->clear();
    log("接続と切断処理を開始します...");

    m_workerThread = new QThread(this); // メインスレッドの親を持つ
    m_worker = new TcpClientWorker(); // QObject::deleteLater() で削除される

    m_worker->moveToThread(m_workerThread); // ワーカーオブジェクトを新しいスレッドに移動

    // シグナルとスロットの接続
    connect(m_workerThread, &QThread::started, m_worker, [this, worker = m_worker]{
        worker->doConnectAndDisconnect("127.0.0.1", 12345);
    });
    connect(m_worker, &TcpClientWorker::connectionSuccess, this, &MainWindow::onConnectionSuccess);
    connect(m_worker, &TcpClientWorker::connectionFailed, this, &MainWindow::onConnectionFailed);
    connect(m_worker, &TcpClientWorker::disconnectedSuccess, this, &MainWindow::onDisconnectedSuccess);
    connect(m_worker, &TcpClientWorker::disconnectedFailed, this, &MainWindow::onDisconnectedFailed);

    // ワーカーがdeleteLater()を呼び出したときにスレッドを終了させる
    connect(m_worker, &TcpClientWorker::destroyed, m_workerThread, &QThread::quit);
    // スレッドが終了したときに（任意で）クリーンアップ
    connect(m_workerThread, &QThread::finished, this, &MainWindow::onWorkerFinished);
    connect(m_workerThread, &QThread::finished, m_workerThread, &QThread::deleteLater); // スレッドオブジェクトも削除

    m_workerThread->start(); // スレッドを開始 (doConnectAndDisconnect が呼ばれる)
}

void MainWindow::onConnectionSuccess()
{
    log("接続に成功しました！");
}

void MainWindow::onConnectionFailed(const QString& error)
{
    log(QString("接続に失敗しました: %1").arg(error));
    m_connectButton->setEnabled(true);
}

void MainWindow::onDisconnectedSuccess()
{
    log("ソケットが正常に切断されました。");
    m_connectButton->setEnabled(true);
}

void MainWindow::onDisconnectedFailed(const QString& error)
{
    log(QString("ソケットの切断に失敗またはタイムアウトしました: %1").arg(error));
    m_connectButton->setEnabled(true);
}

void MainWindow::onWorkerFinished()
{
    log("ワーカースレッドが終了しました。");
}

void MainWindow::log(const QString& message)
{
    m_logTextEdit->append(message);
}

// main.cpp
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

この例のポイント

ワーカースレッドとオブジェクトのライフサイクル管理（deleteLater()）が重要です。
結果はシグナルを通じてメインスレッドの MainWindow に通知され、そこでGUIの更新やログ表示が行われます。
waitForConnected() や waitForDisconnected() のようなブロッキング関数は doConnectAndDisconnect() メソッド内で呼び出されます。
TcpClientWorker オブジェクトが QThread に moveToThread() されます。これにより、TcpClientWorker::doConnectAndDisconnect() メソッドが m_workerThread で実行され、メインGUIスレッドがブロックされるのを防ぎます。

これはQtプログラミングでネットワーク操作を行うための最も一般的な方法であり、waitForDisconnected() のようなブロッキング関数を全く使用しません。これは、イベント駆動型プログラミングの原則に厳密に従います。

#include <QCoreApplication>
#include <QTcpSocket>
#include <QDebug>
#include <QTimer> // タイムアウト処理の代替

class MyClient : public QObject
{
    Q_OBJECT
public:
    explicit MyClient(QObject *parent = nullptr) : QObject(parent)
    {
        connect(&m_socket, &QTcpSocket::connected, this, &MyClient::onConnected);
        connect(&m_socket, &QTcpSocket::disconnected, this, &MyClient::onDisconnected);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
                this, &MyClient::onError);
        connect(&m_socket, &QTcpSocket::readyRead, this, &MyClient::onReadyRead);
        connect(&m_socket, &QTcpSocket::bytesWritten, this, &MyClient::onBytesWritten);

        // 切断処理のタイムアウトを独自に実装する場合
        connect(&m_disconnectTimer, &QTimer::timeout, this, &MyClient::onDisconnectTimeout);
        m_disconnectTimer.setInterval(3000); // 3秒でタイムアウト
        m_disconnectTimer.setSingleShot(true); // 一度だけ実行
    }

    void startConnection(const QString& host, quint16 port)
    {
        qDebug() << "Connecting to" << host << ":" << port << "...";
        m_socket.connectToHost(host, port);
        // 接続状態が変化するとconnected()シグナルが発せられる
    }

    void initiateDisconnect()
    {
        if (m_socket.state() == QAbstractSocket::ConnectedState) {
            qDebug() << "Initiating disconnect...";
            m_socket.disconnectFromHost();
            m_disconnectTimer.start(); // 切断タイムアウトタイマーを開始
        } else {
            qDebug() << "Already disconnected or not connected.";
            QCoreApplication::quit(); // 終了
        }
    }

private slots:
    void onConnected()
    {
        qDebug() << "Connected to server!";
        // データを送信
        QByteArray data = "Hello, server! Please disconnect me.";
        m_socket.write(data);
    }

    void onBytesWritten(qint64 bytes)
    {
        qDebug() << bytes << "bytes written.";
        // すべてのデータが書き込まれたら切断を開始
        if (m_socket.bytesToWrite() == 0) {
            initiateDisconnect();
        }
    }

    void onDisconnected()
    {
        qDebug() << "Disconnected from server!";
        m_disconnectTimer.stop(); // タイマーを停止
        QCoreApplication::quit(); // アプリケーションを終了
    }

    void onError(QAbstractSocket::SocketError socketError)
    {
        qDebug() << "Socket error:" << socketError << "-" << m_socket.errorString();
        m_disconnectTimer.stop(); // タイマーを停止
        QCoreApplication::quit(); // エラー発生で終了
    }

    void onReadyRead()
    {
        qDebug() << "Data available:" << m_socket.readAll();
    }

    void onDisconnectTimeout()
    {
        qDebug() << "Disconnect operation timed out!";
        qDebug() << "Current socket state:" << m_socket.state();
        // 必要に応じて、ここでソケットを強制終了 (abort()) するなどの処理
        if (m_socket.state() == QAbstractSocket::ClosingState) {
            m_socket.abort(); // 強制的に閉じる
            qDebug() << "Socket aborted due to timeout.";
        }
        QCoreApplication::quit(); // 終了
    }

private:
    QTcpSocket m_socket;
    QTimer m_disconnectTimer;
};

// main.cpp
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyClient client;
    client.startConnection("127.0.0.1", 12345);

    return a.exec(); // イベントループを開始
}

#include "main.moc" // Q_OBJECT マクロを使用するために必要

このアプローチは、GUIアプリケーションの応答性を保ちつつ、より複雑なネットワークアプリケーションを構築するためのベストプラクティスです。
切断のタイムアウトは、QTimer を使用して手動で実装されます。
接続、切断、データ送受信は、それぞれ対応するシグナル（connected(), disconnected(), readyRead(), bytesWritten(), error()）のスロットで処理されます。
waitForConnected() や waitForDisconnected() は使用されません。

代わりに、Qtでは**非同期（イベント駆動型）**のプログラミングモデルを採用することが一般的です。これにより、アプリケーションの応答性を維持しつつ、効率的にネットワーク通信を処理できます。

シグナルとスロットによる非同期処理 (最も推奨される方法)

Qtのシグナル＆スロットメカニズムは、非同期イベント処理の核心です。QAbstractSocketは、ソケットの状態変化やデータ送受信などのイベントが発生した際に様々なシグナルを発行します。これらのシグナルをカスタムスロットに接続することで、ノンブロッキングなネットワーク処理を実現できます。

特徴

並行処理の簡素化
多くのネットワーク操作がバックグラウンドで自動的に処理されます。
Qtの流儀
Qtフレームワークの設計思想に最も合致した方法です。
応答性
GUIアプリケーションのUIがフリーズすることなく、スムーズに動作します。
ノンブロッキング
呼び出し元のスレッドをブロックしません。

具体的な方法

error(QAbstractSocket::SocketError) シグナル
ソケットエラーが発生したときに発行されます。切断失敗の原因を特定できます。
stateChanged(QAbstractSocket::SocketState) シグナル
ソケットの状態が変化したときに発行されます。UnconnectedStateへの変化を検出できます。
disconnected() シグナル
ソケットがリモートホストから切断されたとき、またはdisconnectFromHost()が完了したときに発行されます。

コード例

#include <QTcpSocket>
#include <QDebug>
#include <QCoreApplication> // GUIなしの例

class MyClient : public QObject
{
    Q_OBJECT
public:
    explicit MyClient(QObject *parent = nullptr) : QObject(parent)
    {
        // シグナルとスロットの接続
        connect(&m_socket, &QTcpSocket::connected, this, &MyClient::onConnected);
        connect(&m_socket, &QTcpSocket::disconnected, this, &MyClient::onDisconnected);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
                this, &MyClient::onError);
        connect(&m_socket, &QTcpSocket::bytesWritten, this, &MyClient::onBytesWritten);

        // 必要に応じて、接続タイムアウトのタイマーを設定することもできます
        // QTimer::singleShot(5000, this, [this]{
        //     if (m_socket.state() == QAbstractSocket::ConnectingState) {
        //         qDebug() << "Connection timed out!";
        //         m_socket.abort();
        //     }
        // });
    }

    void startConnection(const QString& host, quint16 port)
    {
        qDebug() << "接続を開始します..." << host << ":" << port;
        m_socket.connectToHost(host, port);
    }

    void initiateDisconnect()
    {
        if (m_socket.state() == QAbstractSocket::ConnectedState || m_socket.state() == QAbstractSocket::HostLookupState ||
            m_socket.state() == QAbstractSocket::ConnectingState || m_socket.state() == QAbstractSocket::BoundState ||
            m_socket.state() == QAbstractSocket::ListeningState || m_socket.state() == QAbstractSocket::ClosingState)
        {
            qDebug() << "切断処理を開始します...";
            m_socket.disconnectFromHost();
            // disconnectFromHost() は非同期で切断処理を開始し、完了したらdisconnected()シグナルを発行します。
        } else {
            qDebug() << "ソケットはすでに切断済みか、接続状態ではありません。";
            QCoreApplication::quit(); // アプリケーション終了の例
        }
    }

private slots:
    void onConnected()
    {
        qDebug() << "サーバーに接続しました！";
        // 接続後、データを送信する例
        QByteArray data = "Hello from client! Please close connection.";
        m_socket.write(data);
    }

    void onBytesWritten(qint64 bytes)
    {
        qDebug() << bytes << "バイトのデータを送信しました。";
        // 送信するデータが全て書き込まれたことを確認してから切断を開始
        if (m_socket.bytesToWrite() == 0) {
            initiateDisconnect();
        }
    }

    void onDisconnected()
    {
        qDebug() << "サーバーから切断されました。";
        // 切断後のクリーンアップや次の処理
        QCoreApplication::quit(); // アプリケーションを終了
    }

    void onError(QAbstractSocket::SocketError socketError)
    {
        qDebug() << "ソケットエラーが発生しました:" << socketError << m_socket.errorString();
        // エラーが発生した場合は、強制的にソケットを閉じる
        if (m_socket.state() != QAbstractSocket::UnconnectedState) {
            m_socket.abort();
        }
        QCoreApplication::quit(); // エラー発生で終了
    }

private:
    QTcpSocket m_socket;
};

#include "main.moc" // Q_OBJECT マクロを使用するために必要

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    MyClient client;
    client.startConnection("127.0.0.1", 12345); // テスト用サーバーのIPとポート

    return a.exec(); // イベントループを開始
}

ワーカースレッドの使用 (ブロッキング操作が必要な場合)

もし、どうしてもネットワーク操作をブロッキング的に行いたい、または既存のライブラリがブロッキングAPIしか提供していない場合は、QThreadを使用してそれらの操作を別の（ワーカースレッド）で実行します。これにより、メイン（GUI）スレッドはブロックされず、UIの応答性が保たれます。

特徴

ブロッキング操作の利用
waitForDisconnected()のようなブロッキング関数を安全に使用できます。
複雑性の増加
スレッド間通信（シグナル/スロット）やスレッドのライフサイクル管理が必要になります。
UIの応答性維持
メインスレッドがブロックされないため、GUIアプリケーションのフリーズを防げます。

具体的な方法

注意
QTcpSocketなどのQObject派生クラスは、作成されたスレッドのイベントループで実行される必要があります。moveToThread()はオブジェクトとその子オブジェクトを移動させますが、単にQThreadを継承するだけでは不十分な場合があります。
処理結果は、ワーカースレッドからメインスレッドへシグナルを発行して通知します。
そのスレッド内でQTcpSocket（または他のQAbstractSocket派生クラス）のインスタンスを作成し、waitForDisconnected()を呼び出します。
QThreadのサブクラスを作成するか、QObjectをQThreadにmoveToThread()します。

コード例 (前述のwaitForDisconnected()の例2と同じ概念)

// 詳細は前述の「例2：ワーカースレッドでの waitForDisconnected() の使用」を参照してください。
// TcpClientWorker.h, TcpClientWorker.cpp, MainWindow.h, MainWindow.cpp の各ファイルに分割されます。
// 主なアイデアは、QTcpSocketのインスタンスとそれに関連する waitForDisconnected() 呼び出しを
// メインスレッドとは異なる QThread 上で実行することです。

QEventLoop による一時的なブロッキング (非推奨、限定的な状況のみ)

これは非同期処理の中に一時的な同期処理を組み込む非常にまれなケースで使用されます。QEventLoopを使用すると、特定のシグナルが発行されるまで、またはタイムアウトするまで、呼び出し元のスレッドのイベントループを一時的に実行し、ブロックできます。

特徴

シグナル駆動
特定のシグナルが発行されるまで待機できます。
複雑さ
デッドロックや再入の問題を引き起こす可能性があります。
限定的な使用
ほとんどのGUIアプリケーションでは避けるべきです。

具体的な方法

目的のシグナルが発行されたときにQEventLoop::quit()を呼び出すように接続します。
QEventLoop::exec()を呼び出してイベントループを開始します。
QEventLoopのインスタンスを作成します。

コード例 (切断待機に適用する場合 - あくまで概念的なもので、通常は推奨されません)

// この方法は、ほとんどのGUIアプリケーションでは非推奨です。
// 理解のためだけに示します。

#include <QTcpSocket>
#include <QDebug>
#include <QCoreApplication>
#include <QEventLoop> // QEventLoopを使用

class MyClientWithEventLoopBlock : public QObject
{
    Q_OBJECT
public:
    explicit MyClientWithEventLoopBlock(QObject *parent = nullptr) : QObject(parent)
    {
        connect(&m_socket, &QTcpSocket::connected, this, &MyClientWithEventLoopBlock::onConnected);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error),
                this, &MyClientWithEventLoopBlock::onError);
        connect(&m_socket, &QTcpSocket::bytesWritten, this, &MyClientWithEventLoopBlock::onBytesWritten);
    }

    bool performBlockingDisconnect(const QString& host, quint16 port)
    {
        qDebug() << "接続を開始します..." << host << ":" << port;
        m_socket.connectToHost(host, port);

        QEventLoop connectLoop;
        // 接続が確立されるか、エラーが発生するまでイベントループを実行
        connect(&m_socket, &QTcpSocket::connected, &connectLoop, &QEventLoop::quit);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error), &connectLoop, &QEventLoop::quit);

        QTimer connectTimer;
        connectTimer.setSingleShot(true);
        connect(&connectTimer, &QTimer::timeout, &connectLoop, &QEventLoop::quit);
        connectTimer.start(5000); // 5秒の接続タイムアウト

        connectLoop.exec(); // ここでメインスレッドのイベントループがブロックされる

        if (m_socket.state() != QAbstractSocket::ConnectedState) {
            qDebug() << "接続失敗またはタイムアウト:" << m_socket.errorString();
            return false;
        }
        connectTimer.stop(); // 接続成功ならタイマーを停止
        qDebug() << "接続しました！";

        // データ送信
        QByteArray data = "Disconnect me please!";
        m_socket.write(data);
        QEventLoop writeLoop;
        connect(&m_socket, &QTcpSocket::bytesWritten, &writeLoop, &QEventLoop::quit);
        QTimer writeTimer;
        connect(&writeTimer, &QTimer::timeout, &writeLoop, &QEventLoop::quit);
        writeTimer.setSingleShot(true);
        writeTimer.start(1000); // 1秒で書き込みタイムアウト
        writeLoop.exec();

        if (m_socket.bytesToWrite() > 0) {
            qDebug() << "データ書き込みがタイムアウトしました。";
            return false;
        }
        writeTimer.stop();
        qDebug() << "データ送信済み。";


        m_socket.disconnectFromHost();

        QEventLoop disconnectLoop;
        // 切断されるか、エラーが発生するまでイベントループを実行
        connect(&m_socket, &QTcpSocket::disconnected, &disconnectLoop, &QEventLoop::quit);
        connect(&m_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::error), &disconnectLoop, &QEventLoop::quit);

        QTimer disconnectTimer;
        connectTimer.setSingleShot(true);
        connect(&disconnectTimer, &QTimer::timeout, &disconnectLoop, &QEventLoop::quit);
        disconnectTimer.start(3000); // 3秒の切断タイムアウト

        disconnectLoop.exec(); // ここでもメインスレッドのイベントループがブロックされる

        bool disconnected = (m_socket.state() == QAbstractSocket::UnconnectedState);
        if (disconnected) {
            qDebug() << "正常に切断されました。";
        } else {
            qDebug() << "切断に失敗またはタイムアウトしました:" << m_socket.errorString();
        }
        disconnectTimer.stop(); // 切断成功ならタイマーを停止
        return disconnected;
    }

private slots:
    void onConnected() { /* 必要に応じて処理 */ }
    void onBytesWritten(qint64 bytes) { /* 必要に応じて処理 */ }
    void onError(QAbstractSocket::SocketError socketError) { /* 必要に応じて処理 */ }
};

#include "main.moc"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv); // QApplication でも同様に機能する

    MyClientWithEventLoopBlock client;
    bool success = client.performBlockingDisconnect("127.0.0.1", 12345);

    qDebug() << "最終結果:" << (success ? "成功" : "失敗");

    return 0; // ブロッキングなのでQCoreApplication::exec()は不要
}

設計の複雑さ
非同期のイベント駆動型設計が崩れるため、アプリケーション全体のロジックが複雑になりがちです。
再入
QEventLoop::exec()は、呼び出し元のスロットを中断し、新しいイベントループを開始します。これは、コードの理解を難しくし、予期せぬ動作（デッドロックやスタックオーバーフローなど）につながる可能性があります。

Qtソケット切断のベストプラクティス：waitForDisconnected()の落とし穴と非同期処理

bool QAbstractSocket::waitForDisconnected(int msecs = 30000) とは

使用目的

注意点

メイン（GUI）スレッドのフリーズ / アプリケーションの応答停止

予期せぬタイムアウト / false が返される

waitForDisconnected() を呼び出す前のソケットの状態

QAbstractSocket::abort() との混同

例1：非GUIアプリケーション（コンソールアプリなど）でのシンプルな使用

例2：ワーカースレッドでの waitForDisconnected() の使用 (GUIアプリケーション向け)

TcpClientWorker.h (ワーカースレッドで実行されるオブジェクト)

TcpClientWorker.cpp

MainWindow.h (GUIの例)

MainWindow.cpp

シグナルとスロットによる非同期処理 (最も推奨される方法)

ワーカースレッドの使用 (ブロッキング操作が必要な場合)

QEventLoop による一時的なブロッキング (非推奨、限定的な状況のみ)

`bool QAbstractSocket::waitForDisconnected(int msecs = 30000)` とは

例2：ワーカースレッドでの `waitForDisconnected()` の使用 (GUIアプリケーション向け)

`TcpClientWorker.h` (ワーカースレッドで実行されるオブジェクト)

`TcpClientWorker.cpp`

`MainWindow.h` (GUIの例)

`MainWindow.cpp`