Bloqueo del cliente de Fortune
Muestra cómo crear un cliente para un servicio de red.

QTcpSocket Admite dos enfoques generales para la programación en red:
- El enfoque asíncrono (no bloqueante). Las operaciones se programan y se ejecutan cuando el control vuelve al bucle de eventos de Qt. Cuando finaliza la operación, ` QTcpSocket ` emite una señal. Por ejemplo, ` QTcpSocket::connectToHost()` devuelve el resultado inmediatamente y, una vez establecida la conexión, ` QTcpSocket ` emite ` connected()`.
- El enfoque síncrono (bloqueante). En aplicaciones sin interfaz gráfica de usuario y multihilo, puedes llamar a las funciones
waitFor...()(p. ej., QTcpSocket::waitForConnected()) para suspender el hilo de llamada hasta que la operación haya finalizado, en lugar de conectarte a señales.
La implementación es muy similar a la del ejemplo «Fortune Client», pero en lugar de tener « QTcpSocket » como miembro de la clase principal, realizando operaciones de red asíncronas en el hilo principal, llevaremos a cabo todas las operaciones de red en un hilo independiente y utilizaremos la API de bloqueo de « QTcpSocket ».
El objetivo de este ejemplo es mostrar un patrón que puedes utilizar para simplificar tu código de red, sin perder la capacidad de respuesta de tu interfaz de usuario. El uso de la API de red bloqueante de Qt suele dar lugar a un código más sencillo, pero, debido a su comportamiento bloqueante, solo debe utilizarse en hilos que no sean de la interfaz gráfica de usuario (GUI) para evitar que esta se cuelgue. Sin embargo, al contrario de lo que muchos piensan, el uso de hilos con QThread no añade necesariamente una complejidad inmanejable a la aplicación.
Comenzaremos con la clase `FortuneThread`, que se encarga del código de red.
class FortuneThread : public QThread
{
Q_OBJECT
public:
FortuneThread(QObject *parent = nullptr);
~FortuneThread();
void requestNewFortune(const QString &hostName, quint16 port);
void run() override;
signals:
void newFortune(const QString &fortune);
void error(int socketError, const QString &message);
private:
QString hostName;
quint16 port;
QMutex mutex;
QWaitCondition cond;
bool quit;
};FortuneThread es una subclase de ` QThread ` que proporciona una API para programar solicitudes de predicciones, y cuenta con señales para entregar predicciones e informar de errores. Puedes llamar a `requestNewFortune()` para solicitar una nueva predicción, y el resultado se entrega mediante la señal `newFortune()`. Si se produce algún error, se emite la señal `error()`.
Es importante tener en cuenta que requestNewFortune() se invoca desde el hilo principal (el de la interfaz gráfica de usuario), pero se accederá a los valores del nombre de host y del puerto que almacena desde el hilo de FortuneThread. Dado que vamos a leer y escribir los miembros de datos de FortuneThread desde diferentes hilos de forma simultánea, utilizamos ` QMutex ` para sincronizar el acceso.
void FortuneThread::requestNewFortune(const QString &hostName, quint16 port)
{
QMutexLocker locker(&mutex);
this->hostName = hostName;
this->port = port;
if (!isRunning())
start();
else
cond.wakeOne();
}La función `requestNewFortune()` almacena el nombre de host y el puerto del servidor de Fortune como datos de miembro, y bloqueamos el mutex con ` QMutexLocker ` para proteger estos datos. A continuación, iniciamos el hilo, a menos que ya se esté ejecutando. Volveremos más adelante a la llamada a ` QWaitCondition::wakeOne()`.
void FortuneThread::run()
{
mutex.lock();
QString serverName = hostName;
quint16 serverPort = port;
mutex.unlock();En la función run(), comenzamos adquiriendo el bloqueo del mutex, recuperando el nombre de host y el puerto de los datos de miembro y, a continuación, liberando de nuevo el bloqueo. El caso contra el que nos protegemos es que requestNewFortune() pueda llamarse al mismo tiempo que estamos obteniendo estos datos. QString es reentrante pero no seguro para subprocesos, y también debemos evitar el riesgo, aunque improbable, de leer el nombre de host de una solicitud y el puerto de otra. Y, como habrás adivinado, FortuneThread solo puede gestionar una solicitud a la vez.
La función run() entra ahora en un bucle:
while (!quit) {
const int Timeout = 5 * 1000;
QTcpSocket socket;
socket.connectToHost(serverName, serverPort);El bucle seguirá solicitando frases de la fortuna mientras quit sea falso. Iniciamos nuestra primera solicitud creando un objeto ` QTcpSocket ` en la pila y, a continuación, llamamos a ` connectToHost()`. Esto inicia una operación asíncrona que, una vez que el control vuelva al bucle de eventos de Qt, hará que ` QTcpSocket ` emita ` connected()` o ` error()`.
if (!socket.waitForConnected(Timeout)) {
emit error(socket.error(), socket.errorString());
return;
}Pero, dado que estamos ejecutando el código en un hilo que no es de la interfaz gráfica de usuario, no tenemos que preocuparnos por bloquear la interfaz de usuario. Así que, en lugar de entrar en un bucle de eventos, simplemente llamamos a ` QTcpSocket::waitForConnected()`. Esta función esperará, bloqueando el hilo que la invoca, hasta que ` QTcpSocket ` emita `connected()` o se produzca un error. Si se emite connected(), la función devuelve true; si la conexión falla o se agota el tiempo de espera (lo que en este ejemplo ocurre tras 5 segundos), se devuelve false. QTcpSocket::waitForConnected(), al igual que las demás funciones de waitFor...(), forma parte de la API de bloqueo de QTcpSocket.
Tras esta instrucción, disponemos de un socket conectado con el que trabajar.
QDataStream in(&socket);
in.setVersion(QDataStream::Qt_6_5);
QString fortune;Ahora podemos crear un objeto ` QDataStream `, pasando el socket al constructor de ` QDataStream`, y, al igual que en los demás ejemplos de cliente, establecemos la versión del protocolo de flujo en ` QDataStream::Qt_6_5`.
do {
if (!socket.waitForReadyRead(Timeout)) {
emit error(socket.error(), socket.errorString());
return;
}
in.startTransaction();
in >> fortune;
} while (!in.commitTransaction());Continuamos iniciando un bucle que espera los datos de la cadena de la frase de la fortuna llamando a ` QTcpSocket::waitForReadyRead()`. Si devuelve `false`, abortamos la operación. Tras esta instrucción, iniciamos una transacción de lectura del flujo. Salimos del bucle cuando ` QDataStream::commitTransaction()` devuelve `true`, lo que significa que la carga de la cadena de la frase de la fortuna se ha realizado con éxito. La frase de la fortuna resultante se muestra mediante la llamada a `newFortune()`:
mutex.lock();
emit newFortune(fortune);
cond.wait(&mutex);
serverName = hostName;
serverPort = port;
mutex.unlock();
}La parte final de nuestro bucle consiste en adquirir el mutex para poder leer de forma segura nuestros datos de miembro. A continuación, dejamos que el hilo entre en estado de espera llamando a ` QWaitCondition::wait()`. En este punto, podemos volver a `requestNewFortune()` y examinar detenidamente la llamada a `wakeOne()`:
void FortuneThread::requestNewFortune(const QString &hostName, quint16 port)
{
...
if (!isRunning())
start();
else
cond.wakeOne();
}Lo que ha ocurrido aquí es que, dado que el hilo entra en estado de reposo a la espera de una nueva solicitud, necesitábamos despertarlo de nuevo cuando llegara una nueva solicitud. La función ` QWaitCondition ` se utiliza a menudo en hilos para señalar una llamada de despertar como esta.
FortuneThread::~FortuneThread()
{
mutex.lock();
quit = true;
cond.wakeOne();
mutex.unlock();
wait();
}Para completar el recorrido por FortuneThread, este es el destructor que establece quit en true, despierta el hilo y espera a que este finalice antes de regresar. Esto permite que el bucle while de run() termine su iteración actual. Cuando run() regrese, el hilo terminará y será destruido.
Pasemos ahora a la clase `BlockingClient`:
class BlockingClient : public QWidget
{
Q_OBJECT
public:
BlockingClient(QWidget *parent = nullptr);
private slots:
void requestNewFortune();
void showFortune(const QString &fortune);
void displayError(int socketError, const QString &message);
void enableGetFortuneButton();
private:
QLabel *hostLabel;
QLabel *portLabel;
QLineEdit *hostLineEdit;
QLineEdit *portLineEdit;
QLabel *statusLabel;
QPushButton *getFortuneButton;
QPushButton *quitButton;
QDialogButtonBox *buttonBox;
FortuneThread thread;
QString currentFortune;
};BlockingClient es muy similar a la clase `Client` del ejemplo de Fortune Client, pero en esta clase almacenamos un miembro `FortuneThread` en lugar de un puntero a un ` QTcpSocket`. Cuando el usuario hace clic en el botón «Get Fortune», se invoca el mismo método `slot`, pero su implementación es ligeramente diferente:
connect(&thread, &FortuneThread::newFortune,
this, &BlockingClient::showFortune);
connect(&thread, &FortuneThread::error,
this, &BlockingClient::displayError);Conectamos las dos señales de nuestro `FortuneThread`, `newFortune()` y `error()` (que son algo similares a ` QTcpSocket::readyRead()` y ` QTcpSocket::error()` del ejemplo anterior), a `requestNewFortune()` y `displayError()`.
void BlockingClient::requestNewFortune()
{
getFortuneButton->setEnabled(false);
thread.requestNewFortune(hostLineEdit->text(),
portLineEdit->text().toInt());
}El slot requestNewFortune() llama a FortuneThread::requestNewFortune(), que programa la solicitud. Cuando el hilo ha recibido una nueva predicción y emite newFortune(), se llama a nuestro slot showFortune():
void BlockingClient::showFortune(const QString &nextFortune)
{
if (nextFortune == currentFortune) {
requestNewFortune();
return;
}
currentFortune = nextFortune;
statusLabel->setText(currentFortune);
getFortuneButton->setEnabled(true);
}Aquí, simplemente mostramos la predicción que hemos recibido como argumento.
Véase también Cliente de la fortuna y Servidor de la fortuna.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.