Gibt es einen ExecutorService, der den aktuellen Thread verwendet?

Was ich suche, ist eine kompatible Möglichkeit, die Verwendung eines Thread-Pools zu konfigurieren oder nicht. Im Idealfall sollte der Rest des Codes überhaupt nicht beeinflusst werden. Ich könnte einen Thread-Pool mit 1 Thread verwenden, aber das ist nicht ganz das, was ich will. Irgendwelche Ideen?

ExecutorService es = threads == 0 ? new CurrentThreadExecutor() : Executors.newThreadPoolExecutor(threads);

// es.execute / es.submit / new ExecutorCompletionService(es) etc

Hier ist eine wirklich einfache Executor( ExecutorServicewohlgemerkt) Implementierung, die nur den aktuellen Thread verwendet. Dies aus "Java Concurrency in Practice" stehlen (wesentliche Lektüre).

public class CurrentThreadExecutor implements Executor {
    public void execute(Runnable r) {
        r.run();
    }
}

ExecutorService ist eine aufwändigere Schnittstelle, könnte aber mit dem gleichen Ansatz behandelt werden.

Sie können Guaven verwenden MoreExecutors.newDirectExecutorService()oder MoreExecutors.directExecutor()wenn Sie keine benötigen ExecutorService.

Wenn das Einschließen von Guave zu schwer ist, können Sie etwas fast genauso Gutes implementieren:

public final class SameThreadExecutorService extends ThreadPoolExecutor {
  private final CountDownLatch signal = new CountDownLatch(1);

  private SameThreadExecutorService() {
    super(1, 1, 0, TimeUnit.DAYS, new SynchronousQueue<Runnable>(),
        new ThreadPoolExecutor.CallerRunsPolicy());
  }

  @Override public void shutdown() {
    super.shutdown();
    signal.countDown();
  }

  public static ExecutorService getInstance() {
    return SingletonHolder.instance;
  }

  private static class SingletonHolder {
    static ExecutorService instance = createInstance();    
  }

  private static ExecutorService createInstance() {
    final SameThreadExecutorService instance
        = new SameThreadExecutorService();

    // The executor has one worker thread. Give it a Runnable that waits
    // until the executor service is shut down.
    // All other submitted tasks will use the RejectedExecutionHandler
    // which runs tasks using the  caller's thread.
    instance.submit(new Runnable() {
        @Override public void run() {
          boolean interrupted = false;
          try {
            while (true) {
              try {
                instance.signal.await();
                break;
              } catch (InterruptedException e) {
                interrupted = true;
              }
            }
          } finally {
            if (interrupted) {
              Thread.currentThread().interrupt();
            }
          }
        }});
    return Executors.unconfigurableScheduledExecutorService(instance);
  }
}

Java 8-Stil:

Executor e = Runnable::run;

Ich schrieb eine ExecutorServicebasierend auf der AbstractExecutorService.

/**
 * Executes all submitted tasks directly in the same thread as the caller.
 */
public class SameThreadExecutorService extends AbstractExecutorService {

    //volatile because can be viewed by other threads
    private volatile boolean terminated;

    @Override
    public void shutdown() {
        terminated = true;
    }

    @Override
    public boolean isShutdown() {
        return terminated;
    }

    @Override
    public boolean isTerminated() {
        return terminated;
    }

    @Override
    public boolean awaitTermination(long theTimeout, TimeUnit theUnit) throws InterruptedException {
        shutdown(); // TODO ok to call shutdown? what if the client never called shutdown???
        return terminated;
    }

    @Override
    public List<Runnable> shutdownNow() {
        return Collections.emptyList();
    }

    @Override
    public void execute(Runnable theCommand) {
        theCommand.run();
    }
}

Ich musste denselben "CurrentThreadExecutorService" zu Testzwecken verwenden, und obwohl alle vorgeschlagenen Lösungen nett waren (insbesondere die, die den Guaven-Weg erwähnte ), kam ich auf etwas Ähnliches, wie Peter Lawrey hier vorschlug .

Wie von Axelle Ziegler hier erwähnt , funktioniert Peters Lösung leider nicht wirklich, da ThreadPoolExecutorder maximumPoolSizeKonstruktorparameter überprüft wurde (dh maximumPoolSizenicht sein kann <=0).

Um dies zu umgehen, habe ich Folgendes getan:

private static ExecutorService currentThreadExecutorService() {
    CallerRunsPolicy callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
    return new ThreadPoolExecutor(0, 1, 0L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), callerRunsPolicy) {
        @Override
        public void execute(Runnable command) {
            callerRunsPolicy.rejectedExecution(command, this);
        }
    };
}

Sie können den RejectedExecutionHandler verwenden, um die Aufgabe im aktuellen Thread auszuführen.

public static final ThreadPoolExecutor CURRENT_THREAD_EXECUTOR = new ThreadPoolExecutor(0, 0, 0, TimeUnit.DAYS, new SynchronousQueue<Runnable>(), new RejectedExecutionHandler() {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        r.run();
    }
});

Sie brauchen immer nur eines davon.