มี ExecutorService ที่ใช้เธรดปัจจุบันหรือไม่

สิ่งที่ฉันหลังจากเป็นวิธีที่เข้ากันได้ในการกำหนดค่าการใช้เธรดพูลหรือไม่ ตามหลักการแล้วส่วนที่เหลือของโค้ดไม่ควรได้รับผลกระทบเลย ฉันสามารถใช้เธรดพูลที่มีเธรด 1 เธรด แต่นั่นไม่ใช่สิ่งที่ฉันต้องการ ความคิดใด ๆ ?

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

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

นี่คือการใช้งานที่ง่ายมากExecutor(ไม่ExecutorServiceรังเกียจคุณ) ที่ใช้เฉพาะเธรดปัจจุบันเท่านั้น ขโมยสิ่งนี้มาจาก "Java Concurrency in Practice" (การอ่านที่จำเป็น)

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

ExecutorService เป็นอินเทอร์เฟซที่ซับซ้อนมากขึ้น แต่สามารถจัดการได้ด้วยวิธีการเดียวกัน

คุณสามารถใช้ Guava's MoreExecutors.newDirectExecutorService()หรือMoreExecutors.directExecutor()ถ้าคุณไม่ต้องการไฟล์ExecutorServiceไฟล์.

หากรวม Guava มีน้ำหนักมากเกินไปคุณสามารถนำสิ่งที่ดีไปใช้ได้:

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:

Executor e = Runnable::run;

ฉันเขียนExecutorServiceโดยอิงจากไฟล์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();
    }
}

คุณสามารถใช้ RejectedExecutionHandler เพื่อรันงานในเธรดปัจจุบัน

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

คุณต้องการเพียงหนึ่งในนี้เท่านั้น

ผมใช้เดียวกัน "CurrentThreadExecutorService" สำหรับวัตถุประสงค์ในการทดสอบและแม้จะแก้ปัญหาทุกคนมีความสุข (โดยเฉพาะอย่างยิ่งคนที่กล่าวถึงวิธีที่ฝรั่ง ) ฉันมากับสิ่งที่คล้ายกับสิ่งที่ปีเตอร์ Lawrey แนะนำที่นี่

ดังกล่าวโดย Axelle Ziegler นี่โชคไม่ดีที่วิธีการแก้ปัญหาของปีเตอร์จะไม่จริงเพราะการทำงานของการตรวจสอบนำมาใช้ในThreadPoolExecutorในmaximumPoolSizeพารามิเตอร์คอนสตรัค (เช่นmaximumPoolSizeไม่สามารถ<=0)

เพื่อหลีกเลี่ยงสิ่งนั้นฉันได้ทำสิ่งต่อไปนี้:

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