You can only post inside a signal handler, but you can both post and wait inside threads. It's possible to make a signal-safe queue to put your requests in so your threads can grab them at their leisure. It will need one semaphore, for the interrupt handler, and one mutex, for threads, and two integers: write postion and read position. Both start at zero.

When a signal happens:
Threads will read from the list, by:I originally put sem_wait first, but realized you could let the threads save positions in advance.

If signals happen faster than the threads can handle, the semaphore will keep track(it can count higher than one, it's not a mutex) and not block until they are all handled.

If signals happen way too fast for threads to handle, it's possible for the queue to overflow. Without a safe sem_getvalue this is hard to check for. If you're using gcc, you might try the gcc atomic operations extensions to get the read-index in a safe manner. (For that matter, they might let you dispense with the mutex entirely and grab-increment the read index atomically instead.)

If these functions weren't failing somewhere, why are you deadlocking? Always check the return value.