The simplicity of
pause can conceal serious timing errors that
can make a program hang mysteriously.
It is safe to use
pause if the real work of your program is done
by the signal handlers themselves, and the “main program” does nothing
pause. Each time a signal is delivered, the handler
will do the next batch of work that is to be done, and then return, so
that the main loop of the program can call
You can't safely use
pause to wait until one more signal arrives,
and then resume real work. Even if you arrange for the signal handler
to cooperate by setting a flag, you still can't use
reliably. Here is an example of this problem:
usr_interruptis set by the signal handler. */ if (!usr_interrupt) pause (); /* Do work once the signal arrives. */ ...
This has a bug: the signal could arrive after the variable
usr_interrupt is checked, but before the call to
If no further signals arrive, the process would never wake up again.
You can put an upper limit on the excess waiting by using
in a loop, instead of using
pause. (See Sleeping, for more
sleep.) Here is what this looks like:
usr_interruptis set by the signal handler. while (!usr_interrupt) sleep (1); /* Do work once the signal arrives. */ ...
For some purposes, that is good enough. But with a little more
complexity, you can wait reliably until a particular signal handler is