En esta página

Productor y consumidor con semáforos

El ejemplo «Productor y consumidor con semáforos» muestra cómo utilizar QSemaphore 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; en ese momento, 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.

Los semáforos permiten alcanzar un mayor nivel de concurrencia que los mutex. Si los accesos al búfer estuvieran protegidos por un ` QMutex`, el hilo consumidor no podría acceder al búfer al mismo tiempo que el hilo productor. Sin embargo, no hay ningún inconveniente en 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 los semáforos que lo protegen son variables globales.

Una alternativa al uso de ` QSemaphore ` para resolver el problema del productor-consumidor es utilizar ` QWaitCondition ` y ` QMutex`. Esto es lo que hace el ejemplo «Productor y consumidor con condiciones de espera ».

Variables globales

Empecemos por repasar el búfer circular y los semáforos asociados:

constexpr int DataSize = 100000;

constexpr int BufferSize = 8192;
char buffer[BufferSize];

QSemaphore freeBytes(BufferSize);
QSemaphore usedBytes;

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 semáforos. El semáforo freeBytes controla el área «libre» del búfer (el área que el productor aún no ha llenado de datos o que el consumidor ya ha leído). El semáforo usedBytes controla la zona «ocupada» del búfer (la zona que el productor ha llenado pero que el consumidor aún no ha leído).

Juntos, los semáforos 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.

El semáforo « freeBytes » se inicializa con « BufferSize », ya que, inicialmente, todo el búfer está vacío. El semáforo « usedBytes » se inicializa en 0 (el valor por defecto si no se especifica ninguno).

Clase «Producer»

Repasemos el código de la clase Producer:

class Producer : public QThread
{
public:
    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            freeBytes.acquire();
            buffer[i % BufferSize] = "ACGT"[QRandomGenerator::global()->bounded(4)];
            usedBytes.release();
        }
    }
};

El productor genera DataSize bytes de datos. Antes de escribir un byte en el búfer circular, debe adquirir un byte «libre» utilizando el semáforo freeBytes. La llamada a QSemaphore::acquire() podría bloquearse si el consumidor no ha seguido el ritmo del productor.

Al final, el productor libera un byte utilizando el semáforo usedBytes. El byte «libre» se ha transformado con éxito en un byte «utilizado», listo para ser leído por el consumidor.

Clase «Consumer»

Pasemos ahora a la clase Consumer:

class Consumer : public QThread
{
public:
    void run() override
    {
        for (int i = 0; i < DataSize; ++i) {
            usedBytes.acquire();
            fprintf(stderr, "%c", buffer[i % BufferSize]);
            freeBytes.release();
        }
        fprintf(stderr, "\n");
    }
};

El código es muy similar al del productor, salvo que en esta ocasión adquirimos un byte «usado» y liberamos un byte «libre», en lugar de lo contrario.

La función main()

En ` main()`, creamos los dos subprocesos y llamamos a ` QThread::wait()` para garantizar 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 libere el semáforo usedBytes (su recuento inicial de available() es 0). Una vez que el productor ha colocado un byte en el búfer, freeBytes.available() es BufferSize - 1 y usedBytes.available() es 1. En ese momento, pueden ocurrir dos cosas: o bien el hilo consumidor toma el control y lee ese byte, o bien el hilo productor consigue generar un segundo byte.

El modelo productor-consumidor presentado en este ejemplo permite escribir aplicaciones multihilo de alta concurrencia. En un equipo multiprocesador, el programa puede llegar a ser hasta dos veces más rápido que el programa equivalente basado en mutex, 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. Adquirir y liberar un « QSemaphore » 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.

Proyecto de ejemplo en code.qt.io

© 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.