When to use Guava sameThreadExecutor

Question

I just came across this code:

ExecutorService executorService = MoreExecutors.sameThreadExecutor(); for (int i = 0; i < 10; i++) { executorService.submit(new Callable<Void>() { @Override public Void call() throws Exception { try { Do some work here... return null; } catch (final Exception e) { throw e; } finally { // } } }); } 

The difference between this and the code snippet below? If I understand it correctly, the sameThreadExecutor uses the same thread that calls submit (), which means that all these 10 "jobs" are started one after another in the main thread.

 for (int i = 0; i < 10; i++) { try { Do some work here... } catch (final Exception e) { throw e; } finally { // } } 

Thanks!

Answer 1

First, MoreExecutors#sameThreadExecutor deprecated:

Outdated. Use directExecutor() if you only need Executor and newDirectExecutorService() if you need ListeningExecutorService . This method will be removed in August 2016.

So the question is: when do you need MoreExecutors#directExecutor or MoreExecutors#newDirectExecutorService (the difference between the two is mentioned above - ListeningExecutorService - Guava extension for ListenableFuture s). Answers:

• use it when you need Executor / ExecutorService (for example, your interface requires it) and don’t want concurrency, but just run multithreaded code synchronously
• (implied above) uses it in tests for predictable results
• when you want to implement a simple ExecutorService as newDirectExecutorService yourself, but don’t want to reinvent the wheel (see its source code )
• If you use ListenableFuture##addCallback(ListenableFuture, FutureCallback) , the default is newDirectExecutorService ( "for use when the callback is quick and easy" , also mentions its "dangerous choice in some cases" (see Javadoc ).