Productor y consumidor con condiciones de espera
El ejemplo «Productor y consumidor con condiciones de espera» muestra cómo utilizar QWaitCondition y QMutex para controlar el acceso a un búfer circular compartido por un hilo productor y un hilo consumidor.
El productor escribe datos en el búfer hasta llegar al final del mismo, momento en el que vuelve a empezar desde el principio, sobrescribiendo los datos existentes. El hilo consumidor lee los datos a medida que se producen y los escribe en la salida de error estándar.
Las condiciones de espera permiten alcanzar un mayor nivel de concurrencia que el que se consigue solo con mutexes. Si los accesos al búfer estuvieran protegidos únicamente por un ` QMutex`, el hilo consumidor no podría acceder al búfer al mismo tiempo que el hilo productor. Sin embargo, no supone ningún problema que ambos hilos trabajen en diferentes partes del búfer al mismo tiempo.
El ejemplo consta de dos clases: ` Producer ` y ` Consumer`. Ambas heredan de ` QThread`. El búfer circular utilizado para la comunicación entre estas dos clases y las herramientas de sincronización que lo protegen son variables globales.
Una alternativa al uso de ` QWaitCondition ` y ` QMutex ` para resolver el problema productor-consumidor es utilizar ` QSemaphore`. Esto es lo que hace el ejemplo «Productor y consumidor con semáforos ».
Variables globales
Empecemos por repasar el búfer circular y las herramientas de sincronización asociadas:
constexpr int DataSize = 100000;
constexpr int BufferSize = 8192;
QMutex mutex; // protects the buffer and the counter
char buffer[BufferSize];
int numUsedBytes;
QWaitCondition bufferNotEmpty;
QWaitCondition bufferNotFull;DataSize es la cantidad de datos que generará el productor. Para que el ejemplo sea lo más sencillo posible, la definimos como una constante. ` BufferSize ` es el tamaño del búfer circular. Es menor que ` DataSize`, lo que significa que, en algún momento, el productor llegará al final del búfer y volverá a empezar desde el principio.
Para sincronizar al productor y al consumidor, necesitamos dos condiciones de espera y un mutex. La condición bufferNotEmpty se activa cuando el productor ha generado algunos datos, indicando al consumidor que puede empezar a leerlos. La condición bufferNotFull se activa cuando el consumidor ha leído algunos datos, indicando al productor que puede generar más. El « numUsedBytes » es el número de bytes del búfer que contienen datos.
En conjunto, las condiciones de espera, el mutex y el contador « numUsedBytes » garantizan que el productor nunca se adelante al consumidor en más de « BufferSize » bytes, y que el consumidor nunca lea datos que el productor aún no haya generado.
Clase «Producer»
Repasemos el código de la clase ` Producer `:
class Producer : public QThread
{
public:
explicit Producer(QObject *parent = nullptr)
: QThread(parent)
{
}
private:
void run() override
{
for (int i = 0; i < DataSize; ++i) {
{
const QMutexLocker locker(&mutex);
while (numUsedBytes == BufferSize)
bufferNotFull.wait(&mutex);
}
buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];
{
const QMutexLocker locker(&mutex);
++numUsedBytes;
bufferNotEmpty.wakeAll();
}
}
}
};El productor genera DataSize bytes de datos. Antes de escribir un byte en el búfer circular, debe comprobar primero si el búfer está lleno (es decir, si numUsedBytes es igual a BufferSize). Si el búfer está lleno, el hilo espera en la condición bufferNotFull.
Al final, el productor incrementa numUsedBytes y señala que la condición bufferNotEmpty es verdadera, ya que numUsedBytes es necesariamente mayor que 0.
Protegemos todos los accesos a la variable numUsedBytes con un mutex. Además, la función QWaitCondition::wait() acepta un mutex como argumento. Este mutex se desbloquea antes de que el hilo entre en estado de espera y se bloquea cuando el hilo se activa. Por otra parte, la transición del estado bloqueado al estado de espera es atómica, para evitar que se produzcan condiciones de carrera.
Clase «Consumer»
Pasemos ahora a la clase ` Consumer `:
class Consumer : public QThread
{
public:
explicit Consumer(QObject *parent = nullptr)
: QThread(parent)
{
}
private:
void run() override
{
for (int i = 0; i < DataSize; ++i) {
{
const QMutexLocker locker(&mutex);
while (numUsedBytes == 0)
bufferNotEmpty.wait(&mutex);
}
fprintf(stderr, "%c", buffer[i % BufferSize]);
{
const QMutexLocker locker(&mutex);
--numUsedBytes;
bufferNotFull.wakeAll();
}
}
fprintf(stderr, "\n");
}
};El código es muy similar al del productor. Antes de leer el byte, comprobamos si el búfer está vacío (numUsedBytes es 0), en lugar de si está lleno, y esperamos en la condición bufferNotEmpty si está vacío. Una vez leído el byte, decrementamos numUsedBytes (en lugar de incrementarlo) y señalamos la condición bufferNotFull (en lugar de la condición bufferNotEmpty ).
La función main()
En ` main()`, creamos los dos subprocesos y llamamos a ` QThread::wait()` para asegurarnos de que ambos subprocesos tengan tiempo de terminar antes de salir:
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
Producer producer;
Consumer consumer;
producer.start();
consumer.start();
producer.wait();
consumer.wait();
return 0;
}¿Qué ocurre entonces cuando ejecutamos el programa? Inicialmente, el hilo productor es el único que puede hacer algo; el consumidor está bloqueado a la espera de que se señale la condición « bufferNotEmpty » (numUsedBytes es 0). Una vez que el productor ha colocado un byte en el búfer, numUsedBytes es estrictamente mayor que 0, y se señala la condición « bufferNotEmpty ». En ese momento, pueden ocurrir dos cosas: o bien el hilo consumidor toma el relevo y lee ese byte, o bien el productor llega a producir un segundo byte.
El modelo productor-consumidor presentado en este ejemplo permite escribir aplicaciones multihilo de alta concurrencia. En una máquina multiprocesadora, el programa puede llegar a ser hasta dos veces más rápido que el programa equivalente basado en mutexes, ya que los dos hilos pueden estar activos al mismo tiempo en diferentes partes del búfer.
Sin embargo, hay que tener en cuenta que estas ventajas no siempre se materializan. Bloquear y desbloquear un ` QMutex ` tiene un coste. En la práctica, probablemente valdría la pena dividir el búfer en bloques y operar con bloques en lugar de con bytes individuales. El tamaño del búfer es también un parámetro que debe seleccionarse con cuidado, basándose en la experimentación.
© 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.