QThread: el hilo de PyQt
Cómo combinar threads con interfaces gráficas en PyQt6: del Thread clásico al QThread, sus señales propias y dónde conectarlas.
hub
Threads y PyQt
Hasta ahora trabajamos con programas secuenciales: un único hilo de ejecución que interactúa por consola y archivos. Al construir interfaces gráficas pasamos a un modelo _multithread_, pensado para responder a distintos _inputs_ del usuario sin congelar la ventana.
El uso de _threading_ junto a PyQt es totalmente compatible. Si la tarea de un hilo es larga (descargar algo, calcular, escuchar la red), conviene ejecutarla en un _thread_ aparte para que la interfaz siga respondiendo.
Podemos usar el Thread del módulo threading y comunicarlo con la ventana mediante una señal (pyqtSignal). El _thread_ recibe la señal como parámetro y la emite; la ventana conecta esa señal a un método que actualiza un _label_.
python
from threading import Threadfrom PyQt6.QtCore import pyqtSignal class MiThread(Thread): def __init__(self, senal_actualizar: pyqtSignal) -> None: super().__init__() self.senal_actualizar = senal_actualizar def run(self) -> None: for i in range(10): sleep(0.5) self.senal_actualizar.emit(str(i)) self.senal_actualizar.emit('Status: thread terminado')La señal se define como atributo de clase en la ventana (QWidget) y se conecta en el __init__ con self.senal_thread.connect(self.actualizar_label).
PyQt está construido sobre una arquitectura basada en manejo de eventos. Por eso, un Thread común puede generar problemas de concurrencia con esa arquitectura, y PyQt ofrece su propia implementación de threads: el QThread.
Importante
Cargando Quiz...
memory
QThread: el thread de PyQt
En términos simples, un QThread es un Thread dentro del ecosistema de PyQt6. Provee prácticamente las mismas funcionalidades, pero es mucho más compatible con la arquitectura interna de PyQt. Se importa desde PyQt6.QtCore.
Se usa igual que un Thread: se llama al __init__ de la superclase, se define el método run() con el comportamiento, y se inicia con start().
python
from PyQt6.QtCore import pyqtSignal, QThread class MiThread(QThread): def __init__(self, senal_actualizar: pyqtSignal) -> None: super().__init__() self.senal_actualizar = senal_actualizar def run(self) -> None: for i in range(10):schema
Señales propias del QThread
Una ventaja de QThread sobre Thread es que puede tener sus propias señales definidas como atributos de clase. Esto no es posible con Thread, porque crear señales (pyqtSignal) es exclusivo de objetos del ecosistema PyQt.
Así, la señal vive dentro del propio thread. La única diferencia respecto al caso anterior es que, una vez creado el thread, hay que conectar su señal al método correspondiente.
python
class MiThread(QThread): # La señal se define DENTRO del QThread senal_thread = pyqtSignal(str) def run(self) -> None: for i in range(10): sleep(0.5) self.senal_thread.emit(str(i)) self.senal_thread.emit('Status: QThread terminado')warning
Dónde se conecta una señal
Conectar una señal importa dónde se hace. Veamos un caso con 3 hilos: el principal (Main) crea y ejecuta Thread1 (T1), y T1 a su vez crea y ejecuta Thread2 (T2).
- En Main se conecta
signal_t1con elprintde T1. - Dentro de T1 se conecta
signal_t2con elprintde T2.
Luego, tanto T1 como T2 emiten ambas señales. Se intentan emitir 4 señales… pero solo se ejecutan 3.
python
# Conexiones:# [MAIN] hilo.signal_t1.connect(hilo.print) -> en el hilo principal# [T1] self.t2.signal_t2.connect(self.t2.print) -> dentro del dominio de T1 # Emisiones:# T1 emite signal_t1 -> SI ejecuta print (conectada en Main)# T1 emite signal_t2 -> SI ejecuta print (conectada en el dominio de T1)# T2 emite signal_t1 -> SI ejecuta print (conectada en Main)# T2 emite signal_t2 -> NO se ejecuta (la conexion vive en T1, no en T2 ni en Main)¿Por qué falla la cuarta? La conexión de signal_t2 se hizo dentro del dominio de T1. Esa conexión existe en el "mundo" de T1, pero fuera de él no se conoce. Cuando T2 emite signal_t2, ni en su propio dominio ni en Main existe esa conexión, así que no se dispara nada.