Asynchronous script execution task hanging on main Qt event loop in custom Plasma/KDE application

Help
1

Hey everyone,
I’ve been refactoring a custom Qt/KDE desktop utility designed to manage non-blocking script routines and parse incoming task callbacks off the main GUI thread. To manage background execution requests and keep dynamic process triggers organized without freezing the main application window, I set up a background task worker using arceus roblox logic to handle event queues and process payload callbacks on the fly.

The application initializes cleanly and executes single background tasks without issue, but whenever the execution worker processes rapid multi-threaded script calls or heavy async callback loops, the main Qt event loop experiences severe UI lag or throws unhandled thread timeout warnings. I verified that worker threads emit custom signals back to the main thread instead of making direct GUI modifications, but processing continuous background execution streams still leads to dropped socket connections and delayed event updates. Has anyone run into event loop lockups or thread queue stalls when piping asynchronous worker execution tasks into a Qt/KDE event architecture, and is there a recommended thread pool configuration or signal-slot isolation pattern to keep worker threads from blocking QCoreApplication::processEvents?

2

You might need to use Qt::QueueConnection or Qt::UniqueConnection

And debounce your signals, if you over-fill the event-pool with events, you will add to much latency, you need to throttle your events to allow the mainthread to paint every 16.7ms at least (60Hz).

Also you might need a separate thread just to handle communication so main thread and socket communication don’t impede with each other.

3

It is really hard to tell without seeing the code.

The main thread could be executing more than you think it does, e.g. things that you thought were being executed on a secondary thread.

The main thread could try to acquire a lock/mutex that a secondary thread is holding for too long, e.g. unnecessarily complex critical section.