Class ThreadSafeProgressMonitor

  • All Implemented Interfaces:
    ProgressMonitor

    public class ThreadSafeProgressMonitor
    extends java.lang.Object
    implements ProgressMonitor
    Wrapper around the general ProgressMonitor to make it thread safe. Updates to the underlying ProgressMonitor are made only from the thread that allocated this wrapper. Callers are responsible for ensuring the allocating thread uses pollForUpdates() or waitForCompletion() to update the underlying ProgressMonitor. Only update(int), isCancelled(), and endWorker() may be invoked from a worker thread. All other methods of the ProgressMonitor interface can only be called from the thread that allocates this wrapper.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private java.util.concurrent.locks.ReentrantLock lock  
      private java.lang.Thread mainThread  
      private java.util.concurrent.atomic.AtomicInteger pendingUpdates  
      private ProgressMonitor pm  
      private java.util.concurrent.Semaphore process  
      private java.util.concurrent.atomic.AtomicInteger workers  
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void beginTask​(java.lang.String title, int totalWork)
      Begin processing a single task.
      private void doUpdates()  
      void endTask()
      Finish the current task, so the next can begin.
      void endWorker()
      Notify the monitor a worker is finished.
      boolean isCancelled()
      Check for user task cancellation.
      private boolean isMainThread()  
      void pollForUpdates()
      Non-blocking poll for pending updates.
      void start​(int totalTasks)
      Advise the monitor of the total number of subtasks.
      void startWorker()
      Notify the monitor a worker is starting.
      void startWorkers​(int count)
      Notify the monitor of workers starting.
      void update​(int completed)
      Denote that some work units have been completed.
      void waitForCompletion()
      Process pending updates and wait for workers to finish.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Field Detail

      • lock

        private final java.util.concurrent.locks.ReentrantLock lock
      • mainThread

        private final java.lang.Thread mainThread
      • workers

        private final java.util.concurrent.atomic.AtomicInteger workers
      • pendingUpdates

        private final java.util.concurrent.atomic.AtomicInteger pendingUpdates
      • process

        private final java.util.concurrent.Semaphore process
    • Constructor Detail

      • ThreadSafeProgressMonitor

        public ThreadSafeProgressMonitor​(ProgressMonitor pm)
        Wrap a ProgressMonitor to be thread safe.
        Parameters:
        pm - the underlying monitor to receive events.
    • Method Detail

      • start

        public void start​(int totalTasks)
        Advise the monitor of the total number of subtasks.

        This should be invoked at most once per progress monitor interface.

        Specified by:
        start in interface ProgressMonitor
        Parameters:
        totalTasks - the total number of tasks the caller will need to complete their processing.
      • beginTask

        public void beginTask​(java.lang.String title,
                              int totalWork)
        Begin processing a single task.
        Specified by:
        beginTask in interface ProgressMonitor
        Parameters:
        title - title to describe the task. Callers should publish these as stable string constants that implementations could match against for translation support.
        totalWork - total number of work units the application will perform; ProgressMonitor.UNKNOWN if it cannot be predicted in advance.
      • startWorker

        public void startWorker()
        Notify the monitor a worker is starting.
      • startWorkers

        public void startWorkers​(int count)
        Notify the monitor of workers starting.
        Parameters:
        count - the number of worker threads that are starting.
      • endWorker

        public void endWorker()
        Notify the monitor a worker is finished.
      • pollForUpdates

        public void pollForUpdates()
        Non-blocking poll for pending updates. This method can only be invoked by the same thread that allocated this ThreadSafeProgressMonior.
      • waitForCompletion

        public void waitForCompletion()
                               throws java.lang.InterruptedException
        Process pending updates and wait for workers to finish. This method can only be invoked by the same thread that allocated this ThreadSafeProgressMonior.
        Throws:
        java.lang.InterruptedException - if the main thread is interrupted while waiting for completion of workers.
      • doUpdates

        private void doUpdates()
      • update

        public void update​(int completed)
        Denote that some work units have been completed.

        This is an incremental update; if invoked once per work unit the correct value for our argument is 1, to indicate a single unit of work has been finished by the caller.

        Specified by:
        update in interface ProgressMonitor
        Parameters:
        completed - the number of work units completed since the last call.
      • isCancelled

        public boolean isCancelled()
        Check for user task cancellation.
        Specified by:
        isCancelled in interface ProgressMonitor
        Returns:
        true if the user asked the process to stop working.
      • endTask

        public void endTask()
        Finish the current task, so the next can begin.
        Specified by:
        endTask in interface ProgressMonitor
      • isMainThread

        private boolean isMainThread()