Python raise exception by dbus signal with multithreading concept

Question

I have a specific problem.

1. Main content of program starts with creating Process with dbus loop, where I listen for signals.
2. Content of signals I store in queues. In next part of main I have a threadpool.
3. When some thread takes item from queue, it use specific function(detection) to handle request - based on content of item from queue. (There is operation on database, from where I take data and make some operations depends on request)
4. Every thread in thread pool starts one more thread, which should handle signals (current status and interrupt).

For example: I receive signal, which means I have to handle something on numbers. Any thread from threadpool takes this item from queue and starts function which handle something on numbers - it can take long time. So after any time, I receive signal for current status and I need to send current status of detection - that's why I use threads (for shared memory). Also I can receive interrupt signal from D-Bus ("it takes too long time, so stop this detection and be free for another request"). And the interrupt is the main problem...

So my main questions are:

1. Is there any way, I can raise exception on interrupt signal and stop function (detection)? (I just found solution, but only for catch in main... but I need to catch it in thread which is in threadpool and raise in thread which is in thread in threadpool)
2. Second question is about GIL... does my thread with signal receiving receive all signals? I think it doesn't... (Yes, I use threads_init())

program:

SERVICE = multiprocessing.Process(target=dbus_signal_receiver, args=(...))
SERVICE.daemon = True
SERVICE.start()

class worker(threading.Thread):
    def __init__(self,...):
        threading.Thread.__init__(self)

    def run(self):
        while True:
            #get item from queue
            s = threading.Thread(target=curr_and_interr_signal_handle, args=(ID of item from queue,...))
            s.daemon = True
            s.start()
            #start specific detection based on request

for i in range(number of threads):
    t = worker(...)
    t.daemon = True
    t.start()

and I hoped, something like this will work... (but it doesn't)

...

class worker(threading.Thread):
    def __init__(self,...):
        threading.Thread.__init__(self)

    def run(self):
        while True:
            try:
                #get item from queue
                s = threading.Thread(target=curr_and_interr_signal_handle, args=(ID of item from queue,...))
                s.daemon = True
                s.start()
                #start specific detection based on request
            except raised_interrupt_exception:
                #continue - wait for another request from queue


...

Answer 1

Read about 18.8.1.2. Signals and threads
Python signal handlers are always executed in the main Python thread, even if the signal was received in another thread.
This means that signals can’t be used as a means of inter-thread communication.
You can use the synchronization primitives from the threading module instead.
Besides, only the main thread is allowed to set a new signal handler.

Read about 17.1.7. Event Objects
This is one of the simplest mechanisms for communication between threads: one thread signals an event and other threads wait for it

---

Isn't clear why you have to use thread in thread.
Why could your worker thread not handle detection?

For instance, the following should be do it:

def run(self):
    while self.running.is_set():
        #get item from queue
        #start specific detection based on request