풀 내부의 스레드를 사용해 작업을 실행하는 방법의 장점
* 매번 스레드를 생성하는 대신 재사용하기 떄문에 스레드를 계속해서 생성할 필요가 없다.
* 여러 개의 요청을 처리하는데 필요한 시스템 자원이 줄어드는 효과가 있다.
* 요청을 처리할 스레드가 이미 만들어진 상태로 대기하고 있기 떄문에 반응속도가 향상된다.
* 스레드 풀의 크기를 적절히 조절해 두면 하드웨어 프로세서가 쉬지 않고 동작하도록 할 수 있다.
* 하드웨어 프로세서가 동작중에 메모리를 전부 소모하거나, 서로 경쟁하느라 성능을 잠식하는 현상도 없다.

Executor는 작업을 비동기적으로 실행하기 때문에 앞서 실행시켰던 작업의 상태를 특정 시점에 정확하게 파악하기 어렵다.
* 어떤 작업은 이미 완료됐을 수도 있다.
* 몇 개의 작업은 아직 실행 중일 수 있다.
* 다른 작업은 아직 큐에서 대기 상태에 머물러 있을 수도 있다.

public interface ExecutorService extends Executor {
  void shutdown();
  List<Runnable> shutdownNow();
  boolean isShutdown();
  boolean isTerminated();
  boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
  // .... 작업을 등록할 수 있는 몇 가지 추가 메소드
}

ExecutorService는 세 가지 동작 주기를 가지고 있다.
`실행 중 running` : ExecutorService를 처음 실행하면 running 상태로 동작한다.
`종료 중 shutting down` : shutdown 메소드를 호출하면 안전한 종료 절차를 진행하며 종료 중 상태로 들어간다.
                          이 상태에서는 새로운 작업을 등록받지 않으며, 이전에 등록되어 있던 작업까지는 모두 끝마칠 수 있다.
`종료 terminated` : shutdownNow 메소드를 호출하면 강제 종료 절차를 진행한다. 현재 진행 중인 작업도 가능한 취소시키고, 실행되지 않고 대기중이던 작업은 더 이상 실행시키지 않는다.

public class LifecycleWebServer {
    private final ExecutorService exec = Executors.newCachedThreadPool();

    public void start() throws IOException {
        ServerSocket socket = new ServerSocket(80);
        while (!exec.isShutdown()) {
            try {
                final Socket conn = socket.accept();
                exec.execute(new Runnable() {
                    public void run() {
                        handleRequest(conn);
                    }
                });
            } catch (RejectedExecutionException e) {
                if (!exec.isShutdown())
                    log("task submission rejected", e);
            }
        }
    }

    public void stop() {
        exec.shutdown();
    }

    private void log(String msg, Exception e) {
        Logger.getAnonymousLogger().log(Level.WARNING, msg, e);
    }

    void handleRequest(Socket connection) {
        Request req = readRequest(connection);
        if (isShutdownRequest(req))
            stop();
        else
            dispatchRequest(req);
    }

    interface Request {
    }

    private Request readRequest(Socket s) {
        return null;
    }

    private void dispatchRequest(Request r) {
    }

    private boolean isShutdownRequest(Request r) {
        return false;
    }
}

Timer 클래스의 단점
* Timer에 등록된 작업이 너무 오래 실행되면 등록된 다른 TimerTask 작업이 예정된 시각에 실행되지 못할 가능성이 있다.
* TimerTask가 동작 하던 중 예상치 못한 Exception을 던지는 경우 예측하지 못한 상태로 넘어갈 수 있다.

public class OutOfTime {
    public static void main(String[] args) throws Exception {
        Timer timer = new Timer();
        timer.schedule(new ThrowTask(), 1);
        SECONDS.sleep(1);
        timer.schedule(new ThrowTask(), 1);
        SECONDS.sleep(5);
    }

    static class ThrowTask extends TimerTask {
        public void run() { throw new RuntimeException(); }
    }
}

* BlockingQueue를 구현하면서 ScheduledThreadPoolExecutor와 비슷한 기능을 제공하는 DelayQueue 클래스를 사용하자.
* DelayQueue는 큐 내부에 여러개의 Delayed 객체로 작업을 관리하며, 각각의 Delayed 객체는 저마다의 시간을 가지고 있다.
* DelayQueue를 사용하면 Delayed 내부의 시간이 만료된 객체만 take 메소드로 가져갈 수 있다.
* DelayQueue에서 뽑아내는 객체는 객체마다 저장되어 있던 시각 순서대로 정렬되어 뽑아진다.

public class SingleThreadRenderer {
    void renderPage(CharSequence source) {
        renderText(source);
        List<ImageData> imageData = new ArrayList<ImageData>();
        for (ImageInfo imageInfo : scanForImageInfo(source))
            imageData.add(imageInfo.downloadImage());
        for (ImageData data : imageData)
            renderImage(data);
    }
}

결과를 받아올 때까지 시간이 걸리는 작업이 꽤나 많다.
* 데이터베이스에 쿼리를 보내 결과를 받는 경우도 그렇다.
* 네트웍상의 데이터를 받아오는 경우도 그렇다.
* 물론 아주 복잡한 계산을 하는 경우에도 그렇다.

이처럼 결과를 얻는 데 시간이 걸리는 기능은 Runnable 대신 Callable을 사용하는 것이 모양새가 좋다.
Callable 인터페이스에서는 핵심 메소드인 call을 실행하고 나면 결과 값을 돌려받을 수 있으며, Exception도 발생시킬 수 있다. Executor에는 Callable 뿐만 아니라 Runnable이나 java.security.PrivilegedAction 등 여러 가지 유형의 작업을 실행 할 수 있는 기능이 들어 있다.

get 메소드의 작업 진행 상태 ( 시작되지 않은 상태, 시작한 상태, 완료된 상태 )
* 작업이 완료 상태에 들어가 있으면 get 메소드는 즉시 결과값을 리턴하거나 Exception을 발생시킨다.
* 아직 작업이 시작하지 않았거나 작업이 실행되고 있는 상태이면 작업이 완료될 때까지 대기한다.
* 작업 실행이 모두 끝난 상태에서 Exception이 발생했다면, get 메소드는 원래 발생했던 Exception을 ExecutionExceptio 예외 클래스에 담는다.
* 작업이 중간에 취소 됐으면 get 메소드에서 CancellationException이 발생한다.

public interface Callable<V> {
    V call() throws Exception;
}

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException, CancellationException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExcutionException, CancellationException, TimeoutException;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> task) {
    return new FutureTask<T>(task);
}

public abstract class FutureRenderer {
    private final ExecutorService executor = Executors.newCachedThreadPool();

    void renderPage(CharSequence source) {
        final List<ImageInfo> imageInfos = scanForImageInfo(source);
        Callable<List<ImageData>> task = new Callable<List<ImageData>>() {
                    public List<ImageData> call() {
                        List<ImageData> result = new ArrayList<ImageData>();
                        for (ImageInfo imageInfo : imageInfos)
                            result.add(imageInfo.downloadImage());
                        return result;
                    }
                };

        Future<List<ImageData>> future = executor.submit(task);
        renderText(source);

        try {
            List<ImageData> imageData = future.get();
            for (ImageData data : imageData)
                renderImage(data);
        } catch (InterruptedException e) {
            // Re-assert the thread's interrupted status
            Thread.currentThread().interrupt();
            // We don't need the result, so cancel the task too
            future.cancel(true);
        } catch (ExecutionException e) {
            throw launderThrowable(e.getCause());
        }
    }

    interface ImageData {
    }

    interface ImageInfo {
        ImageData downloadImage();
    }

    abstract void renderText(CharSequence s);

    abstract List<ImageInfo> scanForImageInfo(CharSequence s);

    abstract void renderImage(ImageData i);
}

프로그램이 해야 할 일을 작은 작업으로 쪼개 실행할 때 실제적인 성능상의 이점을 얻으려면, 프로그램이 하는 일을 대량의 동일한 작업으로 재정의해 병렬로 처리할 수 있어야 한다.

private class QueueFuture<V> extends FutureTask<V> {
    QueueingFuture(Callable<V> c) { super(c); }
    QueueingFuture(Runnable t, V r) { super(t, r); }

    protected void done() {
        completionQueue.add(this);
    }
}

* ExecutorCompletionService의 구현 내용은 굉장히 직관적이다.
* 생성 메소드에서 완료된 결과 값을 쌓아 둘 BlockingQueue를 생성한다.
* FutureTask에는 done 메소드가 한 번씩 호출 된다.
* 작업을 처음 등록하면 먼저 FutureTask를 상속받은 QueueingFuture라는 클래스로 변환하는데 QueueingFuture의 done 메소드에서는 결과를 BlockingQueue에 추가하도록 되어 있다.
* take와 poll 메소드를 호출하면 그대로 BlockingQueue의 해당 메소드로 넘겨 처리한다.

public abstract class Renderer {
    private final ExecutorService executor;

    Renderer(ExecutorService executor) {
        this.executor = executor;
    }

    void renderPage(CharSequence source) {
        final List<ImageInfo> info = scanForImageInfo(source);
        CompletionService<ImageData> completionService = new ExecutorCompletionService<ImageData>(executor);
        for (final ImageInfo imageInfo : info)
            completionService.submit(new Callable<ImageData>() {
                public ImageData call() {
                    return imageInfo.downloadImage();
                }
            });

        renderText(source);

        try {
            for (int t = 0, n = info.size(); t < n; t++) {
                Future<ImageData> f = completionService.take();
                ImageData imageData = f.get();
                renderImage(imageData);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            throw launderThrowable(e.getCause());
        }
    }

    interface ImageData {
    }

    interface ImageInfo {
        ImageData downloadImage();
    }

    abstract void renderText(CharSequence s);

    abstract List<ImageInfo> scanForImageInfo(CharSequence s);

    abstract void renderImage(ImageData i);
}

Page renderPageWithAd() throws InterruptedException {
    long endNanos = System.nanoTime() + TIME_BUDGET;
    Future<Ad> f = exec.submit(new FetchAdTask());
    // 광고를 가져오는 작업을 등록했으니, 원래 페이지를 작업한다.
    Page page = renderPageBody();
    Ad ad;
    try {
        // 남은 시간 만큼만 대기한다
        long timeLeft = endNanos - System.nanoTime();
        ad = f.get(timeLeft, NANOSECONDS);
    } catch (ExecutionException e) {
        ad = DEFAULT_AD;
    } catch (TimeoutException e) {
        ad = DEFAULT_AD;
        f.cancel(true);
    }
    page.setAd(ad);
    return page;
}

private class QuoteTask implements Callable<TravelQuote> {
    private final TravelCompany company;
    private final TravelInfo travelInfo;
    ...
    public TravelQuote call() throws Exception {
        return company.solicitQuote(travelInfo);
    }
}

public List<TravelQuote> getRankedTravelQuotes {
    TravelInfo travelInfo, Set<TravelCompany> companies, Comparator<TravelQuote> ranking, long time, TimeUnit unit) throws InterruptedException {
        List<QuoteTask> tasks = new ArrayList<QuoteTask>();
        for (TravelCompany compan : companies)
            tasks.add(new QuoteTask(company, travelInfo));

        List<Future<TravelQuote>> futures = exec.invokeAll(tasks, time, unit);

        List<TravelQuote> quotes = new ArrayList<TravelQuote>(tasks.size());
        Iterator<QuoteTask> taskIter = tasks.iterator();

        for (Future<TravelQuote> f : futures) {
            QuoteTask task = taskIter.next();
            try {
                quotes.add(f.get());
            } catch (ExecutionException e) {
                quotes.add(task.getFailureQuote(e.getCause()));
            } catch (CancellationException e) {
                quotes.add(task.getTimeoutQuote(e));
            }
        }
    }

    Collections.sort(quotes, ranking);
    return quotes;
}