Apakah ada ExecutorService yang menggunakan utas saat ini?

Apa yang saya kejar adalah cara yang kompatibel untuk mengkonfigurasi penggunaan kumpulan thread atau tidak. Idealnya, sisa kode tidak akan terpengaruh sama sekali. Saya bisa menggunakan kumpulan utas dengan 1 utas tetapi itu bukan yang saya inginkan. Ada ide?

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

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

Berikut adalah implementasi yang sangat sederhana Executor(tidak ExecutorService, ingatlah) yang hanya menggunakan utas saat ini. Mencuri ini dari "Java Concurrency in Practice" (bacaan penting).

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

ExecutorService adalah antarmuka yang lebih rumit, tetapi dapat ditangani dengan pendekatan yang sama.

Anda dapat menggunakan Guava's MoreExecutors.newDirectExecutorService(), atau MoreExecutors.directExecutor()jika Anda tidak membutuhkan ExecutorService.

Jika memasukkan Jambu biji terlalu berat, Anda dapat menerapkan sesuatu yang hampir sama baiknya:

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);
  }
}

Gaya Java 8:

Executor e = Runnable::run;

Saya menulis ExecutorServiceberdasarkan 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();
    }
}

Anda dapat menggunakan RejectedExecutionHandler untuk menjalankan tugas di utas saat ini.

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();
    }
});

Anda hanya perlu satu dari ini.

Saya harus menggunakan "CurrentThreadExecutorService" yang sama untuk tujuan pengujian dan, meskipun semua solusi yang disarankan bagus (terutama yang menyebutkan cara Guava ), saya menemukan sesuatu yang mirip dengan apa yang disarankan Peter Lawrey di sini .

Seperti yang disebutkan oleh Axelle Ziegler di sini , sayangnya solusi Peter tidak benar-benar berfungsi karena cek yang dimasukkan ThreadPoolExecutorpada maximumPoolSizeparameter konstruktor (yaitu maximumPoolSizetidak dapat<=0 ).

Untuk menghindari itu, saya melakukan hal berikut:

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);
        }
    };
}