En esta página

Reentrancia y seguridad en subprocesos

A lo largo de la documentación, los términos «reentrante» y «seguro para subprocesos» se utilizan para identificar clases y funciones e indicar cómo pueden utilizarse en aplicaciones multihilo:

  • Una función segura para subprocesos puede invocarse simultáneamente desde varios subprocesos, incluso cuando las invocaciones utilizan datos compartidos, ya que todas las referencias a los datos compartidos se serializan.
  • Una función reentrante también puede ser llamada simultáneamente desde varios hilos, pero solo si cada llamada utiliza sus propios datos.

Por lo tanto, una función segura para subprocesos siempre es reentrante, pero una función reentrante no siempre es segura para subprocesos.

Por extensión, se dice que una clase es reentrante si sus funciones miembro pueden invocarse de forma segura desde varios subprocesos, siempre que cada subproceso utilice una instancia diferente de la clase. La clase es segura para subprocesos si sus funciones miembro pueden invocarse de forma segura desde varios subprocesos, incluso si todos los subprocesos utilizan la misma instancia de la clase.

Nota: Las clasesde Qt solo se documentan como seguras para subprocesos si están pensadas para ser utilizadas por varios subprocesos. Si una función no está marcada como segura para subprocesos o reentrante, no debe utilizarse desde diferentes subprocesos. Si una clase no está marcada como segura para subprocesos o reentrante, no se debe acceder a una instancia específica de dicha clase desde diferentes subprocesos.

Reentrancia

Las clases de C++ suelen ser reentrantes, simplemente porque solo acceden a sus propios datos de miembro. Cualquier hilo puede llamar a una función miembro de una instancia de una clase reentrante, siempre y cuando ningún otro hilo pueda llamar a una función miembro de la misma instancia de la clase al mismo tiempo. Por ejemplo, la clase ` Counter ` que se muestra a continuación es reentrante:

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { ++n; }
    void decrement() { --n; }
    int value() const { return n; }

private:
    int n;
};

La clase no es segura para subprocesos, ya que si varios subprocesos intentan modificar el miembro de datos ` n`, el resultado es indefinido. Esto se debe a que los operadores ` ++ ` y ` -- ` no siempre son atómicos. De hecho, suelen expandirse en tres instrucciones de máquina:

  1. Cargar el valor de la variable en un registro.
  2. Incrementar o decrementar el valor del registro.
  3. Almacenar el valor del registro de nuevo en la memoria principal.

Si el hilo A y el hilo B cargan simultáneamente el valor anterior de la variable, incrementan su registro y lo vuelven a guardar, acaban sobrescribiéndose mutuamente, ¡y la variable solo se incrementa una vez!

Seguridad entre subprocesos

Es evidente que el acceso debe serializarse: el hilo A debe realizar los pasos 1, 2 y 3 sin interrupción (de forma atómica) antes de que el hilo B pueda realizar los mismos pasos; o viceversa. Una forma sencilla de hacer que la clase sea segura para hilos es proteger todos los accesos a los miembros de datos con un ` QMutex`:

class Counter
{
public:
    Counter() { n = 0; }

    void increment() { QMutexLocker locker(&mutex); ++n; }
    void decrement() { QMutexLocker locker(&mutex); --n; }
    int value() const { QMutexLocker locker(&mutex); return n; }

private:
    mutable QMutex mutex;
    int n;
};

La clase ` QMutexLocker ` bloquea automáticamente el mutex en su constructor y lo desbloquea cuando se invoca el destructor, al final de la función. El bloqueo del mutex garantiza que el acceso desde diferentes hilos se serialice. El miembro de datos ` mutex ` se declara con el calificador ` mutable `, ya que necesitamos bloquear y desbloquear el mutex en ` value()`, que es una función `const`.

Notas sobre las clases de Qt

Muchas clases de Qt son reentrantes, pero no están diseñadas para ser seguras para subprocesos, ya que hacerlo supondría una sobrecarga adicional al tener que bloquear y desbloquear repetidamente un ` QMutex`. Por ejemplo, ` QString ` es reentrante, pero no es segura para subprocesos. Se puede acceder de forma segura a diferentes instancias de QString desde varios hilos simultáneamente, pero no se puede acceder de forma segura a la misma instancia de QString desde varios hilos simultáneamente (a menos que se protejan los accesos uno mismo con un QMutex).

Algunas clases y funciones de Qt son seguras para subprocesos. Se trata principalmente de las clases relacionadas con subprocesos (p. ej., QMutex) y de funciones fundamentales (p. ej., QCoreApplication::postEvent()).

Nota: La terminología en el ámbito de la multihilo no está totalmente estandarizada. POSIX utiliza definiciones de «reentrante» y «seguro para subprocesos» que son algo diferentes en sus API de C. Al utilizar otras bibliotecas de clases de C++ orientadas a objetos con Qt, asegúrate de comprender bien las definiciones.

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