Package com.diffplug.common.swt

Class SwtExec

java.lang.Object
java.util.concurrent.AbstractExecutorService
com.diffplug.common.swt.SwtExec
All Implemented Interfaces:
RxExecutor.Has, Executor, ExecutorService, ScheduledExecutorService
public class SwtExec extends AbstractExecutorService implements ScheduledExecutorService, RxExecutor.Has
Executors which execute on the SWT UI thread. There are two primary kinds of `SwtExec`: - async() -> performs actions using Display.asyncExec - immediate() -> performs actions immediately if called from a UI thread, otherwise delegates to `asyncExec`. In addition to the standard executor methods, each `SwtExec` also has a method guardOn, which returns a SwtExec.Guarded instance - the cure for "Widget is disposed" errors. `Guarded` is an Executor and RxSubscriber which stops running tasks and cancels all subscriptions and futures when the guard widget is disposed. ```java SwtExec.immediate().guardOn(myWidget).subscribe(someFuture, value -> myWidget.setContentsTo(value)); ``` In the example above, if the widget is disposed before the future completes, that's fine! No "widget is disposed" errors. blocking() is similar to `async()` and `immediate()`, but it doesn't support `guard` - it's just a simple `Executor`. It performs actions immediately if called from a UI thread, else delegates to the blocking Display.syncExec(java.lang.Runnable). It also has the SwtExec.Blocking.get(Supplier) method, which allows you to easily get a value using a function which must be called on the SWT thread. In the rare scenario where you need higher performance, it is possible to get similar behavior as immediate() but with less overhead (and safety) in swtOnly() and sameThread(). It is very rarely worth this sacrifice.

  • Field Details

    • rxExecutor

      protected final RxExecutor rxExecutor

  • Method Details

    • isRunningOnUI

      public static boolean isRunningOnUI()
      Returns true iff called from the UI thread.

    • async

      public static SwtExec async()
      Returns an "async" SwtExecutor.

      When `execute(Runnable)` is called, the `Runnable` will be passed to Display.asyncExec.

    • immediate

      public static SwtExec immediate()
      Returns an "immediate" SwtExecutor. - When `execute(Runnable)` is called from the SWT thread, the `Runnable` will be executed immediately. - Else, the `Runnable` will be passed to Display.asyncExec. In the rare case that `immediate()` only ever receives events on the SWT thread, there are faster options: - swtOnly is about 3x faster, and will throw an error if you call it from somewhere besides an SWT thread. - sameThread is about 15x faster, and will not throw an error if you call it from somewhere besides an SWT thread (but your callback probably will). It is very rare that sacrificing the safety of `immediate()` is worth it. Here is the approximate throughput of the three options on a Win 10, i7-2630QM machine. - `immediate()` - 2.9 million events per second - `swtOnly()` - 8.3 million events per second - `sameThread()` - 50 million events per second

    • blocking

      public static SwtExec.Blocking blocking()
      Returns a "blocking" Executor for the SWT thread.
      • When `execute(Runnable)` is called from the SWT thread, the `Runnable` will be executed immediately.
      • Else, the `Runnable` will be passed to Display.syncExec.
      This instance also has a blocking get() method for doing a get in the UI thread.

    • timerExec

      public static void timerExec(int ms, Runnable runnable)
      Executes the given runnable in the UI thread after the given delay.

    • guardOn

      public SwtExec.Guarded guardOn(Chit chit)
      Returns an API for performing actions which are guarded on the given Widget.

    • guardOn

      public SwtExec.Guarded guardOn(Widget widget)
      Returns an API for performing actions which are guarded on the given Widget.

    • guardOn

      public SwtExec.Guarded guardOn(com.diffplug.common.swt.ControlWrapper wrapper)
      Returns an API for performing actions which are guarded on the given ControlWrapper.

    • getRxExecutor

      public RxExecutor getRxExecutor()
      Returns an instance of RxExecutor.
      Specified by:
      getRxExecutor in interface RxExecutor.Has

    • execute

      public void execute(Runnable runnable)
      Executes the given command at some time in the future. The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the Executor implementation.
      Specified by:
      execute in interface Executor
      Parameters:
      runnable - the runnable task
      Throws:
      RejectedExecutionException - if this task cannot be accepted for execution.
      NullPointerException - if command is null

    • shutdown

      @Deprecated public void shutdown()
      Deprecated.
      Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.
      Specified by:
      shutdown in interface ExecutorService
      Throws:
      SecurityException - if a security manager exists and shutting down this ExecutorService may manipulate threads that the caller is not permitted to modify because it does not hold RuntimePermission("modifyThread"), or the security manager's checkAccess method denies access.

    • shutdownNow

      @Deprecated public List<Runnable> shutdownNow()
      Deprecated.
      Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

      There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via Thread.interrupt(), so any task that fails to respond to interrupts may never terminate.

      Specified by:
      shutdownNow in interface ExecutorService
      Returns:
      list of tasks that never commenced execution
      Throws:
      SecurityException - if a security manager exists and shutting down this ExecutorService may manipulate threads that the caller is not permitted to modify because it does not hold RuntimePermission("modifyThread"), or the security manager's checkAccess method denies access.

    • isShutdown

      @Deprecated public boolean isShutdown()
      Deprecated.
      Returns true if this executor has been shut down.
      Specified by:
      isShutdown in interface ExecutorService
      Returns:
      true if this executor has been shut down

    • isTerminated

      @Deprecated public boolean isTerminated()
      Deprecated.
      Returns true if all tasks have completed following shut down. Note that isTerminated is never true unless either shutdown or shutdownNow was called first.
      Specified by:
      isTerminated in interface ExecutorService
      Returns:
      true if all tasks have completed following shut down

    • awaitTermination

      @Deprecated public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException
      Deprecated.
      Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
      Specified by:
      awaitTermination in interface ExecutorService
      Parameters:
      timeout - the maximum time to wait
      unit - the time unit of the timeout argument
      Returns:
      true if this executor terminated and false if the timeout elapsed before termination
      Throws:
      InterruptedException - if interrupted while waiting

    • schedule

      public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
      Creates and executes a one-shot action that becomes enabled after the given delay.
      Specified by:
      schedule in interface ScheduledExecutorService
      Parameters:
      command - the task to execute
      delay - the time from now to delay execution
      unit - the time unit of the delay parameter
      Returns:
      a ScheduledFuture representing pending completion of the task and whose get() method will return null upon completion
      Throws:
      RejectedExecutionException - if the task cannot be scheduled for execution
      NullPointerException - if command is null

    • schedule

      public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
      Creates and executes a ScheduledFuture that becomes enabled after the given delay.
      Specified by:
      schedule in interface ScheduledExecutorService
      Parameters:
      callable - the function to execute
      delay - the time from now to delay execution
      unit - the time unit of the delay parameter
      Returns:
      a ScheduledFuture that can be used to extract result or cancel
      Throws:
      RejectedExecutionException - if the task cannot be scheduled for execution
      NullPointerException - if callable is null

    • scheduleAtFixedRate

      public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
      Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on. If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor. If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute.
      Specified by:
      scheduleAtFixedRate in interface ScheduledExecutorService
      Parameters:
      command - the task to execute
      initialDelay - the time to delay first execution
      period - the period between successive executions
      unit - the time unit of the initialDelay and period parameters
      Returns:
      a ScheduledFuture representing pending completion of the task, and whose get() method will throw an exception upon cancellation
      Throws:
      RejectedExecutionException - if the task cannot be scheduled for execution
      NullPointerException - if command is null
      IllegalArgumentException - if period less than or equal to zero

    • scheduleWithFixedDelay

      public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
      Creates and executes a periodic action that becomes enabled first after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next. If any execution of the task encounters an exception, subsequent executions are suppressed. Otherwise, the task will only terminate via cancellation or termination of the executor.
      Specified by:
      scheduleWithFixedDelay in interface ScheduledExecutorService
      Parameters:
      command - the task to execute
      initialDelay - the time to delay first execution
      delay - the delay between the termination of one execution and the commencement of the next
      unit - the time unit of the initialDelay and delay parameters
      Returns:
      a ScheduledFuture representing pending completion of the task, and whose get() method will throw an exception upon cancellation
      Throws:
      RejectedExecutionException - if the task cannot be scheduled for execution
      NullPointerException - if command is null
      IllegalArgumentException - if delay less than or equal to zero

    • swtOnly

      public static SwtExec swtOnly()
      UNLESS YOU HAVE PERFORMANCE PROBLEMS, USE immediate() INSTEAD. Returns an SwtExecutor which can only be called from the SWT thread, and runs actions immediately. Has the same behavior as immediate() for callbacks on the SWT thread. For values not on the SWT thread, `immediate()` behaves likes async(), while `swtOnly()` throws an exception.

    • sameThread

      public static SwtExec sameThread()
      UNLESS YOU HAVE PERFORMANCE PROBLEMS, USE immediate() INSTEAD. Returns an SwtExec which runs actions immediately, without checking whether they were called from the SWT thread or not.