{@code Executor} implementation that will automatically first associate any argument {@link Runnable} instances with the currently available {@link Subject} and then dispatch the Subject-enabled runnable to an underlying delegate {@link Executor} instance. <p/> This is a simplification for applications that want to execute code as the currently executing {@code Subject} on another thread, but don't want or need to call the {@link Subject#associateWith(Runnable)} method and dispatch to a Thread manually. This simplifies code and reduces Shiro dependencies across application source code. <p/> Consider this code that could be repeated in many places across an application: <pre> {@link Runnable Runnable} applicationWork = //instantiate or acquire Runnable from somewhere {@link Subject Subject} subject = {@link SecurityUtils SecurityUtils}.{@link SecurityUtils#getSubject() getSubject()}; {@link Runnable Runnable} work = subject.{@link Subject#associateWith(Runnable) associateWith(applicationWork)}; {@link Executor anExecutor}.{@link Executor#execute(Runnable) execute(work)}; </pre> Instead, if the {@code Executor} instance used in application code is an instance of this class (which delegates to the target Executor that you want), all places in code like the above reduce to this: <pre> {@link Runnable Runnable} applicationWork = //instantiate or acquire Runnable from somewhere {@link Executor anExecutor}.{@link Executor#execute(Runnable) execute(work)}; </pre> Notice there is no use of the Shiro API in the 2nd code block, encouraging the principle of loose coupling across your codebase.