public class EnhancedThreadSignalHandler extends AbstractSignalHandler implements InterruptHandler
Thread.interrupt()
on the worker thread. This signal handler is also registered as an interrupt
handler with ThreadSignalHandler.setInterruptHandler(InterruptHandler)
,
and will throw a SignalReceivedException
when interrupted.
When the worker thread becomes aware of the notification it should call
getReceivedSignals()
or hasReceived(Signal)
to find out which signal that was sent and then take the proper action.
There are usually three different ways to get a notification about the signal:
InterruptedException
is thrown. This usually happens when the
code involves blocking IO operations or other blocking synchronization
functions.
SignalReceivedException
is thrown. This is usually
thrown from the BASE core when it detects that the thread has been
interrupted.
ThreadSignalHandler.checkInterrupted()
is used instead.
// ... code in worker thread threadSignalHandler.setWorkerThread(); beginTransaction(); boolean done = false; boolean interrupted = false; while (!done && !interrupted) { try { done = doSomeWork(); // NOTE! This must not take forever! ThreadSignalHandler.checkInterrupted(); } catch (SignalReceivedException ex) { // This exception can be thrown from BASE core when a thread is interrupted interrupted = true; } catch (InterruptedException ex) { // NOTE! Try-catch is only needed if thread calls a blocking method interrupted = true; } } if (interrupted) { if (threadSignalHandler.hasReceived(Signal.SHUTDOWN)) { // save current state so that we can continue when the system // is up and running again } rollbackTransaction(); } else { commitTransaction(); }
Modifier and Type | Field and Description |
---|---|
private static org.slf4j.Logger |
logger
Log signals processing.
|
private List<Signal> |
received |
private Thread |
workerThread
The worker thread that should be interrupted when a signal is
received.
|
Constructor and Description |
---|
EnhancedThreadSignalHandler(Collection<Signal> supported)
Create a new signal handler that supports the specified
signals.
|
EnhancedThreadSignalHandler(Signal... supported)
Create a signal handler that supports the specified
signals.
|
Modifier and Type | Method and Description |
---|---|
void |
checkForSignals()
If at least one signal has been received a
SignalReceivedException
is thrown. |
List<Signal> |
getReceivedSignals()
Get the list of received signals.
|
void |
handleInterrupt()
Throws a
SignalReceivedException if one ore more
signals has been received. |
void |
handleSignal(Signal signal)
When a supported signal is received
Thread.interrupt() is called
on the worker thread that was registered when this object was created. |
boolean |
hasReceived(Signal signal)
Check if the given signal has been received by this signal handler.
|
boolean |
hasReceivedSignals()
Check if any signals has been received by this handler.
|
void |
setWorkerThread()
Set the worker thread to the current thread.
|
addSignal, getSupportedSignals, removeSignal, supports
private static final org.slf4j.Logger logger
private Thread workerThread
public EnhancedThreadSignalHandler(Collection<Signal> supported)
supported
- A collection with the signals that are initially supported.
More signals can be added with AbstractSignalHandler.addSignal(Signal)
public EnhancedThreadSignalHandler(Signal... supported)
supported
- An array with the signals that are initially supported.
More signals can be added with AbstractSignalHandler.addSignal(Signal)
public void handleSignal(Signal signal)
Thread.interrupt()
is called
on the worker thread that was registered when this object was created.
Note that this method is called from a different thread. The worker thread
is busy doing something else. If the worker thread has already ended,
this method does nothing. It is the responsibility of the worker
thread to regularly check with this signal handler if it has recieved
any signals.handleSignal
in interface SignalHandler
signal
- The signalUnsupportedSignalException
- If signal is not supportedpublic void handleInterrupt()
SignalReceivedException
if one ore more
signals has been received.handleInterrupt
in interface InterruptHandler
public void setWorkerThread()
ThreadSignalHandler.setInterruptHandler(InterruptHandler)
.public boolean hasReceivedSignals()
public List<Signal> getReceivedSignals()
public void checkForSignals()
SignalReceivedException
is thrown. This method clears the received signals.public boolean hasReceived(Signal signal)
signal
- The signal to check for