Clean Code

•
Where there are shared objects/values
•
The code that can cause concurrent read/update issues
•
How to guard such concurrent issues from happening
As demonstrated in the 
ExecutorClientScheduler.java
on page 321, the 
Executor
frame-
work introduced in Java 5 allows for sophisticated execution using thread pools. This is a
class in the 
java.util.concurrent
package.
If you are creating threads and are not using a thread pool or 
are
using a hand-written
one, you should consider using the 
Executor
. It will make your code cleaner, easier to fol-
low, and smaller.
The 
Executor
framework will pool threads, resize automatically, and recreate threads
if necessary. It also supports 
futures,
a common concurrent programming construct. The
Executor
framework works with classes that implement 
Runnable
and also works with
classes that implement the 
Callable
interface. A 
Callable
looks like a 
Runnable
, but it can
return a result, which is a common need in multithreaded solutions.
A 
future
is handy when code needs to execute multiple, independent operations and
wait for both to finish:
public String processRequest(String message) throws Exception {
Callable makeExternalCall = new Callable() {

---

327
Knowing Your Library
public String call() throws Exception {
String result = "";
// make external request
return result;
}
};
Future result = executorService.submit(makeExternalCall);
String partialResult = doSomeLocalProcessing();
return result.get() + partialResult;
}
In this example, the method starts executing the 
makeExternalCall
object. The method con-
tinues other processing. The final line calls 
result.get()
, which blocks until the future
completes.