Có ExecutorService sử dụng luồng hiện tại không?

Điều tôi mong muốn là một cách tương thích để định cấu hình việc sử dụng nhóm luồng hay không. Tốt nhất là phần còn lại của mã không bị ảnh hưởng gì cả. Tôi có thể sử dụng một nhóm chủ đề với 1 chủ đề nhưng đó không phải là điều tôi muốn. Bất kỳ ý tưởng?

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

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

Đây là một triển khai thực sự đơn giản Executor(không phải ExecutorService, bạn nhớ) chỉ sử dụng luồng hiện tại. Đánh cắp điều này từ "Java Concurrency in Practice" (bài đọc cần thiết).

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

ExecutorService là một giao diện phức tạp hơn, nhưng có thể được xử lý với cùng một cách tiếp cận.

Bạn có thể sử dụng Guava's MoreExecutors.newDirectExecutorService(), hoặc MoreExecutors.directExecutor()nếu bạn không cần ExecutorService.

Nếu bao gồm Ổi quá nặng, bạn có thể thực hiện một cái gì đó gần như tốt:

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

Kiểu Java 8:

Executor e = Runnable::run;

Tôi đã viết một ExecutorServicedựa trên 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();
    }
}

Tôi đã phải sử dụng cùng một "CurrentThreadExecutorService" cho mục đích thử nghiệm và mặc dù tất cả các giải pháp được đề xuất đều tốt (đặc biệt là giải pháp đề cập đến cách Guava ), tôi đã nghĩ ra một thứ tương tự như những gì Peter Lawrey đề xuất ở đây .

Như được đề cập bởi Axelle Ziegler ở đây , không may là giải pháp của Peter sẽ không thực sự hoạt động vì kiểm tra được giới thiệu ThreadPoolExecutortrên maximumPoolSizetham số hàm tạo (tức là maximumPoolSizekhông thể được <=0).

Để phá vỡ điều đó, tôi đã làm như sau:

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

Bạn có thể sử dụng RejectedExecutionHandler để chạy tác vụ trong luồng hiện tại.

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

Bạn chỉ cần một trong những thứ này.