Call to function connected to Signal from QThread is executed in a different thread than the main thread.

class threadCheckConnection(QObject):
    
    finished = Signal()
    sqs_checker = Signal()
    refresh_data = Signal()
    
    def __init__(self, lock, parent):
        super().__init__()
        self.lock = threading.Lock()  # Threading lock to handle thread safety
        self.Parent = parent    def run(self):
        # Simulating connection checking logic
        if verificar_conexion_internet():
            if not Global.INTERNET_CONNECTION:
                logging.info('Se ha recuperado la conexión a Internet')
            Global.INTERNET_CONNECTION = True
            
            if not Global.BD_CONNECTION:
                try:
                    Global.BD_CONNECTION = DBManager.init_connection()
                except:
                    Global.BD_CONNECTION = None
                        
                if Global.BD_CONNECTION: 
                    self.refresh_data.emit()  # Emitting signal to refresh data
                
        else:
            if Global.INTERNET_CONNECTION:
                logging.error('Se ha perdido la conexión a Internet')
            Global.BD_CONNECTION = False
            Global.INTERNET_CONNECTION = False
            DBManager.close()        
            
        self.finished.emit()  # Emitting finished 


self.objThread_check_connection = QThread() 
self.obj_check_connection = threadCheckConnection(self.reconnect_lock, self)
self.obj_check_connection.moveToThread(self.objThread_check_connection)
self.obj_check_connection.finished.connect(self.objThread_check_connection.quit, Qt.ConnectionType.QueuedConnection)
self.obj_check_connection.refresh_data.connect(self.reconnect_one, Qt.ConnectionType.QueuedConnection)
self.objThread_check_connection.started.connect(self.obj_check_connection.run)


 
{{{}{}}}Here, {{refresh_data}} is connected to the {{reconnect_one}} method, which triggers when there is an internet reconnection. The {{reconnect_one}} method handles UI updates and other critical operations that need to run on the main thread.
The problem arises because the following code confirms that {{reconnect_one}} is running in a non-main thread:

 

@cursor_wait
def reconnect_one(self):
    # Check the current thread
    current_thread = QThread.currentThread()
    print(f"Hilo actual: \{current_thread}")
    
    # Check if it's the main thread
    main_thread = QCoreApplication.instance().thread()
    if current_thread == main_thread:
        print("This is the main thread.") 
    else:
        print("This isn’t the main thread.")