QThread Class
La clase QThread proporciona una forma independiente de la plataforma para gestionar hilos. Más...
| Cabecera: | #include <QThread> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Hereda: | QObject |
- Lista de todos los miembros, incluyendo los heredados
- QThread es parte de Threading Classes.
Tipos Públicos
| enum | Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, HighPriority, …, InheritPriority } |
(since 6.9) enum class | QualityOfService { Auto, High, Eco } |
Funciones Públicas
| QThread(QObject *parent = nullptr) | |
| virtual | ~QThread() |
| QAbstractEventDispatcher * | eventDispatcher() const |
(since 6.8) bool | isCurrentThread() const |
| bool | isFinished() const |
| bool | isInterruptionRequested() const |
| bool | isRunning() const |
| int | loopLevel() const |
| QThread::Priority | priority() const |
| void | requestInterruption() |
(since 6.9) QThread::QualityOfService | serviceLevel() const |
| void | setEventDispatcher(QAbstractEventDispatcher *eventDispatcher) |
| void | setPriority(QThread::Priority priority) |
(since 6.9) void | setServiceLevel(QThread::QualityOfService serviceLevel) |
| void | setStackSize(uint stackSize) |
| uint | stackSize() const |
| bool | wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever)) |
| bool | wait(unsigned long time) |
Funciones Públicas Reimplementadas
| virtual bool | event(QEvent *event) override |
Ranuras Públicas
| void | exit(int returnCode = 0) |
| void | quit() |
| void | start(QThread::Priority priority = InheritPriority) |
| void | terminate() |
Señales
Miembros públicos estáticos
| QThread * | create(Function &&f, Args &&... args) |
| QThread * | currentThread() |
| Qt::HANDLE | currentThreadId() |
| int | idealThreadCount() |
(since 6.8) bool | isMainThread() |
| void | msleep(unsigned long msecs) |
(since 6.6) void | sleep(std::chrono::nanoseconds nsecs) |
| void | sleep(unsigned long secs) |
| void | usleep(unsigned long usecs) |
| void | yieldCurrentThread() |
Funciones protegidas
Miembros estáticos protegidos
| void | setTerminationEnabled(bool enabled = true) |
Descripción Detallada
Un objeto QThread gestiona un hilo de control dentro del programa. Los QThreads comienzan a ejecutarse en run(). Por defecto, run() inicia el bucle de eventos llamando a exec() y ejecuta un bucle de eventos Qt dentro del hilo.
Puedes usar objetos worker moviéndolos al thread usando QObject::moveToThread().
class Worker : public QObject { Q_OBJECT public slots: void doWork(const QString ¶meter) { QString result; /* ... here is the expensive or blocking operation ... */ emit resultReady(result); } signals: void resultReady(const QString &result); }; class Controller : public QObject { Q_OBJECT QThread workerThread; public: Controller() { Worker *worker = new Worker; worker->moveToThread(&workerThread); connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater); connect(this, &Controller::operate, worker, &Worker::doWork); connect(worker, &Worker::resultReady, this, &Controller::handleResults); workerThread.start(); } ~Controller() { workerThread.quit(); workerThread.wait(); } public slots: void handleResults(const QString &); signals: void operate(const QString &); };
El código dentro de la ranura del Worker se ejecutaría entonces en un hilo separado. Sin embargo, eres libre de conectar las ranuras del Worker a cualquier señal, desde cualquier objeto, en cualquier hilo. Es seguro conectar señales y ranuras a través de diferentes hilos, gracias a un mecanismo llamado queued connections.
Otra forma de hacer que el código se ejecute en un hilo separado, es subclasificar QThread y reimplementar run(). Por ejemplo:
class WorkerThread : public QThread { Q_OBJECT public: explicit WorkerThread(QObject *parent = nullptr) : QThread(parent) { } protected: void run() override { QString result; /* ... here is the expensive or blocking operation ... */ emit resultReady(result); } signals: void resultReady(const QString &s); }; void MyObject::startWorkInAThread() { WorkerThread *workerThread = new WorkerThread(this); connect(workerThread, &WorkerThread::resultReady, this, &MyObject::handleResults); connect(workerThread, &WorkerThread::finished, workerThread, &QObject::deleteLater); workerThread->start(); }
En ese ejemplo, el hilo saldrá después de que la función run haya retornado. No habrá ningún bucle de eventos ejecutándose en el hilo a menos que llames a exec().
Es importante recordar que una instancia de QThread lives in el antiguo hilo que lo instanció, no en el nuevo hilo que llama a run(). Esto significa que todas las ranuras en cola de QThread y invoked methods se ejecutarán en el antiguo hilo. Por lo tanto, un desarrollador que desee invocar ranuras en el nuevo hilo debe utilizar el enfoque trabajador-objeto; las nuevas ranuras no deben implementarse directamente en un QThread subclaseado.
A diferencia de las ranuras en cola o los métodos invocados, los métodos llamados directamente en el objeto QThread se ejecutarán en el hilo que llama al método. Cuando subclase QThread, tenga en cuenta que el constructor se ejecuta en el antiguo hilo mientras que run() se ejecuta en el nuevo hilo. Si se accede a una variable miembro desde ambas funciones, entonces se accede a la variable desde dos hilos diferentes. Compruebe que es seguro hacerlo.
Nota: Se debe tener cuidado cuando se interactúa con objetos a través de diferentes hilos. Como regla general, las funciones sólo pueden ser llamadas desde el hilo que creó el objeto QThread (p.e. setPriority()), a menos que la documentación indique lo contrario. Ver Sincronizar Hilos para más detalles.
Gestionando Hilos
QThread le notificará a través de una señal cuando el hilo está started() y finished(), o puede utilizar isFinished() y isRunning() para consultar el estado del hilo.
Puedes detener el hilo llamando a exit() o quit(). En casos extremos, puedes querer forzar terminate() un hilo en ejecución. Sin embargo, hacerlo es peligroso y se desaconseja. Lee la documentación de terminate() y setTerminationEnabled() para obtener información detallada.
A menudo querrás desasignar objetos que viven en un hilo cuando éste finaliza. Para ello, conecta la señal finished() a QObject::deleteLater().
Utilice wait() para bloquear el hilo que llama, hasta que el otro hilo haya terminado la ejecución (o hasta que haya pasado un tiempo especificado).
QThread también proporciona funciones sleep estáticas, independientes de la plataforma: sleep(), msleep(), y usleep() permiten una resolución de segundos completos, milisegundos y microsegundos respectivamente.
Nota: wait() y las funciones sleep() deberían ser innecesarias en general, ya que Qt es un framework dirigido por eventos. En lugar de wait(), considere escuchar la señal finished(). En lugar de las funciones sleep(), considere el uso de QChronoTimer.
Las funciones estáticas currentThreadId() y currentThread() devuelven identificadores para el hilo actualmente en ejecución. La primera devuelve un ID específico de la plataforma para el hilo; la segunda devuelve un puntero QThread.
Para elegir el nombre que se le dará a tu hilo (como el identificado por el comando ps -L en Linux, por ejemplo), puedes llamar a setObjectName() antes de iniciar el hilo. Si no llamas a setObjectName(), el nombre dado a tu hilo será el nombre de la clase del tipo de tiempo de ejecución de tu objeto hilo (por ejemplo, "RenderThread" en el caso del ejemplo Mandelbrot, ya que ese es el nombre de la subclase QThread). Tenga en cuenta que esto no está disponible actualmente en las versiones de Windows.
Vea también Multi-threading en Qt, QThreadStorage, Sincronizando Threads, Mandelbrot, Productor y Consumidor usando Semáforos, y Productor y Consumidor usando Condiciones de Espera.
Documentación de tipos de miembros
enum QThread::Priority
Este tipo enum indica cómo debe programar el sistema operativo los hilos recién creados.
| Constante | Valor | Descripción |
|---|---|---|
QThread::IdlePriority | 0 | programado sólo cuando no hay otros subprocesos en ejecución. |
QThread::LowestPriority | 1 | programado con menos frecuencia que LowPriority. |
QThread::LowPriority | 2 | programado con menos frecuencia que NormalPriority. |
QThread::NormalPriority | 3 | la prioridad por defecto del sistema operativo. |
QThread::HighPriority | 4 | programado con más frecuencia que NormalPriority. |
QThread::HighestPriority | 5 | programado más a menudo que HighPriority. |
QThread::TimeCriticalPriority | 6 | programado con la mayor frecuencia posible. |
QThread::InheritPriority | 7 | utilizar la misma prioridad que el subproceso de creación. Esta es la prioridad por defecto. |
[since 6.9] enum class QThread::QualityOfService
Este enum describe el nivel de calidad de servicio de un subproceso y proporciona al programador información sobre el tipo de trabajo que realiza el subproceso. En plataformas con diferentes perfiles de CPU, o con la capacidad de reducir el reloj de ciertos núcleos de una CPU, esto permite al programador seleccionar o configurar un núcleo de CPU con características de rendimiento y energía adecuadas para el subproceso.
| Constante | Valor | Descripción |
|---|---|---|
QThread::QualityOfService::Auto | 0 | El valor por defecto, dejando que el programador decida en qué núcleo de CPU ejecutar el subproceso. |
QThread::QualityOfService::High | 1 | El programador debe ejecutar este subproceso en un núcleo de CPU de alto rendimiento. |
QThread::QualityOfService::Eco | 2 | El programador debería ejecutar este subproceso en un núcleo de CPU de bajo consumo. |
Este enum se introdujo en Qt 6.9.
Ver también Priority, serviceLevel(), y QThreadPool::serviceLevel().
Documentación de la Función Miembro
[explicit] QThread::QThread(QObject *parent = nullptr)
Construye un nuevo QThread para gestionar un nuevo hilo. El parent toma posesión del QThread. El hilo no comienza a ejecutarse hasta que se llama a start().
Véase también start().
[virtual noexcept] QThread::~QThread()
Destruye el objeto QThread.
Tenga en cuenta que la eliminación de un objeto QThread no detendrá la ejecución del hilo que gestiona. Borrar un QThread en ejecución (es decir, isFinished() devuelve false) provocará la caída del programa. Espere a la señal finished() antes de borrar el QThread.
Desde Qt 6.3, se permite borrar una instancia QThread creada por una llamada a QThread::create() incluso si el hilo correspondiente sigue en ejecución. En tal caso, Qt enviará una petición de interrupción a ese hilo (mediante requestInterruption()); pedirá al bucle de eventos del hilo (si existe) que salga (mediante quit()); y se bloqueará hasta que el hilo haya terminado.
Ver también create(), isInterruptionRequested(), exec(), y quit().
[static] template <typename Function, typename... Args> QThread *QThread::create(Function &&f, Args &&... args)
Crea un nuevo objeto QThread que ejecutará la función f con los argumentos args.
El nuevo hilo no se inicia - debe iniciarse mediante una llamada explícita a start(). Esto te permite conectarte a sus señales, mover QObjects al hilo, elegir la prioridad del nuevo hilo, etc. La función f será llamada en el nuevo hilo.
Devuelve la instancia QThread recién creada.
Nota: el que llama adquiere la propiedad de la instancia QThread devuelta.
Advertencia: no llame a start() en la instancia QThread devuelta más de una vez; si lo hace, se producirá un comportamiento indefinido.
Véase también start().
[static] QThread *QThread::currentThread()
Devuelve un puntero a un QThread que gestiona el hilo actualmente en ejecución.
[static noexcept] Qt::HANDLE QThread::currentThreadId()
Devuelve el manejador de la hebra que se está ejecutando en ese momento.
Advertencia: El handle devuelto por esta función se utiliza para fines internos y no debe ser utilizado en ningún código de aplicación.
Nota: En Windows, esta función devuelve el DWORD (Windows-Thread ID) devuelto por la función Win32 GetCurrentThreadId(), no el pseudo-HANDLE (Windows-Thread HANDLE) devuelto por la función Win32 GetCurrentThread().
[override virtual] bool QThread::event(QEvent *event)
Reimplementa: QObject::event(QEvent *e).
QAbstractEventDispatcher *QThread::eventDispatcher() const
Devuelve un puntero al objeto despachador de eventos para el hilo. Si no existe un despachador de eventos para el hilo, esta función devuelve nullptr.
Véase también setEventDispatcher().
[protected] int QThread::exec()
Entra en el bucle de eventos y espera hasta que se llama a exit(), devolviendo el valor que se pasó a exit(). El valor devuelto es 0 si exit() es llamado a través de quit().
Esta función está pensada para ser llamada desde dentro de run(). Es necesario llamar a esta función para iniciar el manejo de eventos.
Nota: Esto sólo puede ser llamado dentro del propio hilo, es decir, cuando es el hilo actual.
Véase también quit() y exit().
[slot] void QThread::exit(int returnCode = 0)
Indica al bucle de eventos del hilo que salga con un código de retorno.
Después de llamar a esta función, el hilo abandona el bucle de eventos y vuelve de la llamada a QEventLoop::exec(). La función QEventLoop::exec() devuelve returnCode.
Por convención, un returnCode de 0 significa éxito, cualquier valor distinto de cero indica un error.
Nótese que a diferencia de la función de la librería C del mismo nombre, esta función sí devuelve al llamador - es el procesamiento de eventos el que se detiene.
No se iniciará ningún QEventLoops más en este hilo hasta que QThread::exec() haya sido llamado de nuevo. Si el eventloop en QThread::exec() no se está ejecutando entonces la siguiente llamada a QThread::exec() también retornará inmediatamente.
Nota: Esta función es thread-safe.
Véase también quit() y QEventLoop.
[private signal] void QThread::finished()
Esta señal se emite desde el hilo asociado justo antes de que termine de ejecutarse.
Cuando se emite esta señal, el bucle de eventos ya ha dejado de ejecutarse. No se procesarán más eventos en el hilo, excepto los eventos de borrado diferido. Esta señal puede conectarse a QObject::deleteLater(), para liberar objetos en ese hilo.
Nota: Si el subproceso asociado ha finalizado mediante terminate(), no está definido desde qué subproceso se emite esta señal.
Nota: Esta señal es privada. Puede ser utilizada en conexiones de señales pero no puede ser emitida por el usuario.
Véase también started().
[static noexcept] int QThread::idealThreadCount()
Devuelve el número ideal de hilos que este proceso puede ejecutar en paralelo. Esto se hace consultando el número de procesadores lógicos disponibles para este proceso (si es soportado por este SO) o el número total de procesadores lógicos en el sistema. Esta función devuelve 1 si no se ha podido determinar ninguno de los dos valores.
Nota: En sistemas operativos que soportan establecer la afinidad de una hebra a un subconjunto de todos los procesadores lógicos, el valor devuelto por esta función puede cambiar entre hebras y con el tiempo.
Nota: En los sistemas operativos que soportan la conexión y desconexión en caliente de la CPU, el valor devuelto por esta función también puede cambiar con el tiempo (y tenga en cuenta que las CPUs pueden ser encendidas y apagadas por software, sin un cambio físico de hardware).
[noexcept, since 6.8] bool QThread::isCurrentThread() const
Devuelve true si este hilo es QThread::currentThread.
Esta función se introdujo en Qt 6.8.
Véase también currentThreadId().
bool QThread::isFinished() const
Devuelve true si el hilo ha finalizado; en caso contrario devuelve false.
Un hilo se considera terminado si ha regresado de la función run() y la señal finished() ha sido emitida.
Tenga en cuenta que el hilo puede seguir ejecutándose durante un tiempo arbitrario después de que se emita la señal finished(), ejecutando operaciones de limpieza como la ejecución de los destructores de las variables thread_local. Para sincronizar con todos los efectos del hilo, llame a wait() y verifique que devuelve true.
Nota: Esta función es thread-safe.
Véase también isRunning().
bool QThread::isInterruptionRequested() const
Devuelve true si la tarea que se ejecuta en este hilo debe ser interrumpida. Se puede solicitar una interrupción mediante requestInterruption().
Esta función se puede utilizar para hacer que las tareas de larga ejecución se puedan interrumpir limpiamente. Nunca comprobar o actuar sobre el valor devuelto por esta función es seguro, sin embargo es recomendable hacerlo regularmente en funciones de larga ejecución. Tenga cuidado de no llamarla demasiado a menudo, para mantener la sobrecarga baja.
void long_task() { forever { if ( QThread::currentThread()->isInterruptionRequested() ) { return; } } }
Nota: Esto sólo puede ser llamado dentro del propio hilo, es decir, cuando es el hilo actual.
Véase también currentThread() y requestInterruption().
[static noexcept, since 6.8] bool QThread::isMainThread()
Devuelve si la hebra que se está ejecutando actualmente es la hebra principal.
El subproceso principal es el subproceso en el que se creó QCoreApplication. Normalmente es el hilo que llamó a la función main(), pero no necesariamente. Es el hilo que está procesando los eventos GUI y en el que se pueden crear objetos gráficos (QWindow, QWidget).
Esta función se introdujo en Qt 6.8.
Véase también currentThread() y QCoreApplication::instance().
bool QThread::isRunning() const
Devuelve true si el hilo está en ejecución; en caso contrario devuelve false.
Se considera que un hilo está en ejecución si QThread se ha iniciado con start() pero aún no ha finalizado.
Tenga en cuenta que el hilo puede seguir ejecutándose durante un tiempo arbitrario después de que se emita la señal finished(), ejecutando operaciones de limpieza como la ejecución de los destructores de las variables thread_local. Para sincronizar con todos los efectos del hilo, llame a wait() y verifique que devuelve true.
Nota: Esta función es thread-safe.
Véase también isFinished().
int QThread::loopLevel() const
Devuelve el nivel actual del bucle de eventos del subproceso.
Nota: Esto sólo puede ser llamado dentro del propio hilo, es decir, cuando es el hilo actual.
[static] void QThread::msleep(unsigned long msecs)
Esta es una función sobrecargada, equivalente a llamar:
QThread::sleep(std::chrono::milliseconds{msecs});
Nota: Esta función no garantiza la precisión. La aplicación puede dormir más tiempo que msecs en condiciones de mucha carga. Algunos sistemas operativos pueden redondear msecs a 10 ms o 15 ms.
Véase también sleep() y usleep().
QThread::Priority QThread::priority() const
Devuelve la prioridad de un subproceso en ejecución. Si el subproceso no se está ejecutando, esta función devuelve InheritPriority.
Véase también Priority, setPriority(), y start().
[slot] void QThread::quit()
Indica al bucle de eventos del hilo que salga con el código de retorno 0 (éxito). Equivale a llamar a QThread::exit(0).
Esta función no hace nada si el hilo no tiene un bucle de eventos.
Nota: Esta función es segura para los hilos.
Ver también exit() y QEventLoop.
void QThread::requestInterruption()
Solicitar la interrupción del hilo. Esa solicitud es consultiva y depende del código que se ejecuta en el hilo decidir si debe actuar ante dicha solicitud y cómo debe hacerlo. Esta función no detiene ningún bucle de eventos que se ejecute en el hilo y no lo termina de ninguna manera.
Esta función no tiene ningún efecto sobre el subproceso principal, y no hace nada si el subproceso no se está ejecutando actualmente.
Nota: Esta función es thread-safe.
Véase también isInterruptionRequested().
[virtual protected] void QThread::run()
El punto de inicio del hilo. Después de llamar a start(), el hilo recién creado llama a esta función. La implementación por defecto simplemente llama a exec().
Puedes reimplementar esta función para facilitar la gestión avanzada de hilos. La devolución de este método finalizará la ejecución del hilo.
Véase también start() y wait().
[since 6.9] QThread::QualityOfService QThread::serviceLevel() const
Devuelve el nivel actual de Calidad de Servicio del hilo.
Esta función se introdujo en Qt 6.9.
Véase también setServiceLevel() y QThreadPool::serviceLevel().
void QThread::setEventDispatcher(QAbstractEventDispatcher *eventDispatcher)
Establece el despachador de eventos para el hilo a eventDispatcher. Esto sólo es posible mientras no haya un despachador de eventos instalado para el hilo todavía.
Un despachador de eventos es creado automáticamente para el hilo principal cuando QCoreApplication es instanciado y en start() para los hilos auxiliares.
Este método toma posesión del objeto.
Véase también eventDispatcher().
void QThread::setPriority(QThread::Priority priority)
Esta función establece el priority para un hilo en ejecución. Si el hilo no se está ejecutando, esta función no hace nada y devuelve inmediatamente. Utilice start() para iniciar un hilo con una prioridad específica.
El argumento priority puede ser cualquier valor del enum QThread::Priority excepto InheritPriority.
El efecto del parámetro priority depende de la política de programación del sistema operativo. En particular, priority será ignorado en sistemas que no soporten prioridades de hilos (como en Linux, ver http://linux.die.net/man/2/sched_setscheduler para más detalles).
Véase también Priority, priority(), y start().
[since 6.9] void QThread::setServiceLevel(QThread::QualityOfService serviceLevel)
Establece el nivel de Calidad de Servicio del objeto thread a serviceLevel. ¡Esto sólo puede ser llamado desde el propio thread o antes de que el thread sea iniciado!
Actualmente sólo está implementado en plataformas Apple y Windows. La llamada a la función se completará con éxito en otras plataformas, pero actualmente no tendrá ningún efecto.
Esta función se introdujo en Qt 6.9.
Véase también serviceLevel() y QThreadPool::setServiceLevel().
void QThread::setStackSize(uint stackSize)
Establece el tamaño de la pila para el subproceso en stackSize. Si stackSize es cero, el sistema operativo o el tiempo de ejecución elegirán un valor por defecto. De lo contrario, el tamaño de la pila del subproceso será el valor proporcionado (que puede redondearse hacia arriba o hacia abajo).
En la mayoría de los sistemas operativos, la cantidad de memoria asignada para servir a la pila será inicialmente menor que stackSize y crecerá a medida que el subproceso utilice la pila. Este parámetro establece el tamaño máximo al que se le permitirá crecer (es decir, establece el tamaño del espacio de memoria virtual que se le permite ocupar a la pila).
Esta función sólo puede invocarse antes de que se inicie el subproceso.
Atención: La mayoría de los sistemas operativos establecen límites mínimos y máximos para el tamaño de la pila de los subprocesos. El hilo no se iniciará si el tamaño de la pila está fuera de estos límites.
Véase también stackSize().
[static protected] void QThread::setTerminationEnabled(bool enabled = true)
Activa o desactiva la terminación del hilo actual basándose en el parámetro enabled. El hilo debe haber sido iniciado por QThread.
Cuando enabled es falso, la terminación está deshabilitada. Las futuras llamadas a QThread::terminate() retornarán inmediatamente sin efecto. En su lugar, la terminación se aplaza hasta que se habilita la terminación.
Cuando enabled es verdadero, la terminación está habilitada. Las futuras llamadas a QThread::terminate() terminarán el hilo normalmente. Si la terminación ha sido diferida (es decir, QThread::terminate() fue llamado con la terminación deshabilitada), esta función terminará el hilo de llamada inmediatamente. Tenga en cuenta que esta función no devolverá en este caso.
Véase también terminate().
[static, since 6.6] void QThread::sleep(std::chrono::nanoseconds nsecs)
Obliga al subproceso actual a dormir durante nsecs.
Evita usar esta función si necesitas esperar a que cambie una condición dada. En su lugar, conecte una ranura a la señal que indica el cambio o utilice un manejador de eventos (véase QObject::event()).
Nota: Esta función no garantiza la precisión. La aplicación puede dormir más tiempo que nsecs bajo condiciones de carga pesada.
Esta función se introdujo en Qt 6.6.
[static] void QThread::sleep(unsigned long secs)
Obliga al subproceso actual a dormir durante secs segundos.
Esta es una función sobrecargada, equivalente a llamar:
QThread::sleep(std::chrono::seconds{secs});
Ver también msleep() y usleep().
uint QThread::stackSize() const
Devuelve el tamaño máximo de pila para el hilo (si se ha establecido con setStackSize()); en caso contrario devuelve cero.
Véase también setStackSize().
[slot] void QThread::start(QThread::Priority priority = InheritPriority)
Inicia la ejecución del hilo llamando a run(). El sistema operativo programará el hilo de acuerdo con el parámetro priority. Si el hilo ya se está ejecutando, esta función no hace nada.
El efecto del parámetro priority depende de la política de programación del sistema operativo. En particular, priority será ignorado en sistemas que no soporten prioridades de hilos (como en Linux, véase la documentación sched_setscheduler para más detalles).
Véase también run() y terminate().
[private signal] void QThread::started()
Esta señal se emite desde el hilo asociado cuando comienza a ejecutarse, por lo que cualquier ranura conectada a él puede ser llamada a través de una invocación en cola. Mientras que el evento puede haber sido publicado antes de que run() sea llamado, cualquier entrega de la señal entre hilos puede estar aún pendiente.
Nota: Se trata de una señal privada. Puede ser utilizada en conexiones de señales pero no puede ser emitida por el usuario.
Véase también run() y finished().
[slot] void QThread::terminate()
Finaliza la ejecución de la hebra. El hilo puede o no terminar inmediatamente, dependiendo de las políticas de programación del sistema operativo. Utilice QThread::wait() después de terminate(), para estar seguro.
Cuando el subproceso finaliza, todos los subprocesos que estén esperando a que termine se activarán.
Advertencia: Esta función es peligrosa y se desaconseja su uso. El hilo puede ser terminado en cualquier punto de su ruta de código. Los hilos pueden ser terminados mientras modifican datos. No hay posibilidad de que el hilo se limpie a sí mismo, desbloquee cualquier mutex, etc. En resumen, utilice esta función sólo si es absolutamente necesario.
La terminación puede ser explícitamente activada o desactivada llamando a QThread::setTerminationEnabled(). Si se llama a esta función mientras la terminación está deshabilitada, la terminación se pospone hasta que se vuelva a habilitar. Consulte la documentación de QThread::setTerminationEnabled() para obtener más información.
Nota: Esta función es segura para hilos.
Véase también setTerminationEnabled().
[static] void QThread::usleep(unsigned long usecs)
Esta es una función sobrecargada, equivalente a llamar:
QThread::sleep(std::chrono::microseconds{secs});
Nota: Esta función no garantiza la precisión. La aplicación puede dormir más tiempo que usecs en condiciones de mucha carga. Algunos sistemas operativos pueden redondear usecs a 10 ms o 15 ms; en Windows, se redondeará a un múltiplo de 1 ms.
Véase también sleep() y msleep().
bool QThread::wait(QDeadlineTimer deadline = QDeadlineTimer(QDeadlineTimer::Forever))
Bloquea el hilo hasta que se cumpla alguna de estas condiciones:
- El hilo asociado a este objeto QThread ha finalizado la ejecución (es decir, cuando vuelve de run()). Esta función devolverá true si el hilo ha finalizado. También devuelve true si el hilo aún no se ha iniciado.
- Se ha alcanzado el plazo de deadline. Esta función devolverá false si se alcanza la fecha límite.
Un temporizador de fecha límite establecido en QDeadlineTimer::Forever (el valor predeterminado) nunca agotará el tiempo: en este caso, la función sólo devuelve cuando el hilo vuelve de run() o si el hilo aún no se ha iniciado.
Esto proporciona una funcionalidad similar a la función POSIX pthread_join().
Nota: En algunos sistemas operativos, esta función puede devolver true mientras el hilo del sistema operativo todavía se está ejecutando y puede estar ejecutando código de limpieza como los destructores de C++11 thread_local. Los sistemas operativos en los que esta función sólo devuelve true después de que el hilo del sistema operativo haya salido completamente incluyen los sistemas operativos Linux, Windows y Apple.
Véase también sleep() y terminate().
bool QThread::wait(unsigned long time)
time es el tiempo de espera en milisegundos. Si time es ULONG_MAX, la espera nunca se agotará.
Esta es una función sobrecargada.
[static] void QThread::yieldCurrentThread()
Cede la ejecución del subproceso actual a otro subproceso ejecutable, si existe. Tenga en cuenta que el sistema operativo decide a qué subproceso cambiar.
© 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.
