Class EnhancedThreadSignalHandler

  • All Implemented Interfaces:
    InterruptHandler, SignalHandler, Action

    public class EnhancedThreadSignalHandler
    extends AbstractSignalHandler
    implements InterruptHandler
    An extension to the thread signal handler that supports any number of signals. When a signal is recieved it will call 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:

    // ... 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();
    }
    
    Since:
    2.16
    Author:
    nicklas
    Last modified
    $Date: 2015-05-12 11:27:08 +0200 (ti, 12 maj 2015) $
    • Field Detail

      • logger

        private static final org.slf4j.Logger logger
        Log signals processing.
      • workerThread

        private Thread workerThread
        The worker thread that should be interrupted when a signal is received.
    • Constructor Detail

      • EnhancedThreadSignalHandler

        public EnhancedThreadSignalHandler​(Collection<Signal> supported)
        Create a new signal handler that supports the specified signals.
        Parameters:
        supported - A collection with the signals that are initially supported. More signals can be added with AbstractSignalHandler.addSignal(Signal)
      • EnhancedThreadSignalHandler

        public EnhancedThreadSignalHandler​(Signal... supported)
        Create a signal handler that supports the specified signals.
        Parameters:
        supported - An array with the signals that are initially supported. More signals can be added with AbstractSignalHandler.addSignal(Signal)
    • Method Detail

      • handleSignal

        public 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. 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.
        Specified by:
        handleSignal in interface SignalHandler
        Parameters:
        signal - The signal
        Throws:
        UnsupportedSignalException - If signal is not supported
      • hasReceivedSignals

        public boolean hasReceivedSignals()
        Check if any signals has been received by this handler.
        Returns:
        TRUE if at least one signal has been received, FALSE otherwise
      • getReceivedSignals

        public List<Signal> getReceivedSignals()
        Get the list of received signals. Calling this method clears the internal list and if no signals are received in the meantime, the next call to this method will return null.
        Returns:
        A list with signals in the order they were received, or null if no signals has been received
      • checkForSignals

        public void checkForSignals()
        If at least one signal has been received a SignalReceivedException is thrown. This method clears the received signals.
      • hasReceived

        public boolean hasReceived​(Signal signal)
        Check if the given signal has been received by this signal handler.
        Parameters:
        signal - The signal to check for
        Returns:
        TRUE if the signal has been received, FALSE otherwise