Mevcut iş parçacığını kullanan bir ExecutorService var mı?

Peşinde olduğum şey, bir iş parçacığı havuzunun kullanımını yapılandırmak için uyumlu bir yol. İdeal olarak, kodun geri kalanı hiç etkilenmemelidir. 1 iş parçacığı olan bir iş parçacığı havuzu kullanabilirim ama istediğim tam olarak bu değil. Herhangi bir fikir?

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

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

Burada , yalnızca mevcut iş parçacığını kullanan gerçekten basit Executor( ExecutorServiceunutmayın) bir uygulama var. Bunu "Uygulamada Java Eşzamanlılığı" ndan çalmak (temel okuma).

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

ExecutorService daha ayrıntılı bir arayüzdür, ancak aynı yaklaşımla ele alınabilir.

Guava'yı kullanabilirsiniz MoreExecutors.newDirectExecutorService()veya MoreExecutors.directExecutor()ihtiyacınız yoksa ExecutorService.

Guava'yı dahil etmek çok ağırsa, neredeyse aynı derecede iyi bir şey uygulayabilirsiniz:

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 stili:

Executor e = Runnable::run;

Bir ExecutorServicedayanarak yazdım 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();
    }
}

Görevi geçerli iş parçacığı içinde çalıştırmak için RejectedExecutionHandler öğesini kullanabilirsiniz.

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

Şimdiye kadar bunlardan sadece birine ihtiyacınız var.

Test amacıyla aynı "CurrentThreadExecutorService" hizmetini kullanmak zorunda kaldım ve önerilen tüm çözümler güzel olmasına rağmen (özellikle Guava yönteminden bahseden ), Peter Lawrey'nin burada önerdiğine benzer bir şey buldum .

Axelle Ziegler tarafından belirtildiği gibi burada maalesef Peter çözüm çünkü tanıtılan çek değil aslında çalışma olacak ThreadPoolExecutorüzerinde maximumPoolSizeYapıcı parametre (yani maximumPoolSizeolamaz <=0).

Bunu aşmak için şunları yaptım:

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