//返回一個(gè)被當(dāng)前EventExecutorGroup管理的EventExecutor對(duì)象
		EventExecutor next();
    //返回一個(gè)EventExecutor類型的迭代器
    @Override
    Iterator<EventExecutor> iterator();

    //返回一個(gè)被當(dāng)前EventExecutorGroup管理的EventExecutor對(duì)象
		EventExecutor next();
    //返回一個(gè)EventExecutor類型的迭代器
    @Override
    Iterator<EventExecutor> iterator();

public interface ExecutorService extends Executor {

    /**
     * 啟動(dòng)有序關(guān)閉，在關(guān)閉過程中會(huì)繼續(xù)執(zhí)行以前提交的任務(wù)，但是不接受新的任務(wù)
     */
    void shutdown();

    /**
     * 嘗試停止所有正在執(zhí)行的任務(wù)，停止處理等待的任務(wù)，并返回一個(gè)等待執(zhí)行的任務(wù)列表
     */
    List<Runnable> shutdownNow();

    /**
     * 如果此執(zhí)行程序已關(guān)閉，則返回true
     */
    boolean isShutdown();

    /**
     * 如果關(guān)閉后所有任務(wù)都已完成，則返回true
     * 只有首先調(diào)用了shutdown()、shutdownNow()方法才有可能返回true，否則一定為false
     */
    boolean isTerminated();

    /**
     * 阻塞，shutdown后所有任務(wù)執(zhí)行完成、超時(shí)、當(dāng)前線程被終端，那個(gè)先發(fā)生那個(gè)優(yōu)先；
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 提交一個(gè)帶返回值的執(zhí)行任務(wù)，并返回一個(gè)Future代表將要返回的任務(wù)結(jié)果
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     * 提交一個(gè)可運(yùn)行任務(wù)以供執(zhí)行，并返回一個(gè)表示該任務(wù)的Future。Future的get方法將在成功完成后返回給定的結(jié)果。
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * 提交一個(gè)可運(yùn)行任務(wù)以供執(zhí)行，并返回一個(gè)表示該任務(wù)的Future。Future的get方法在成功完成后將返回null。
     */
    Future<?> submit(Runnable task);

    /**
     * 執(zhí)行給定的多個(gè)任務(wù)，返回一個(gè)持有執(zhí)行狀態(tài)和結(jié)果的Future列表。
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
     * 執(zhí)行給定的多個(gè)任務(wù)，返回一個(gè)持有執(zhí)行狀態(tài)和結(jié)果的Future列表。
     * 當(dāng)所有的任務(wù)完成或超時(shí)過期Future#isDone都將返回ture
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 執(zhí)行給定的多個(gè)任務(wù)，返回其中一個(gè)執(zhí)行成功的結(jié)果
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    /**
     * 執(zhí)行給定的多個(gè)任務(wù)，返回其中一個(gè)執(zhí)行成功的結(jié)果
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

class NetworkService implements Runnable {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize) throws IOException {
        serverSocket = new ServerSocket(port);
        pool = Executors.newFixedThreadPool(poolSize);
    }

    public void run() { // run the service      
        try {
            for (; ; ) {
                pool.execute(new Handler(serverSocket.accept()));
            }
        } catch (IOException ex) {
            pool.shutdown();
        }
    }
}

class Handler implements Runnable {
    private final Socket socket;

    Handler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        // read and service request on socket   
    }
}

    void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // Disable new tasks from being submitted    
        try {
            // Wait a while for existing tasks to terminate      
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow(); // Cancel currently executing tasks        
                // Wait a while for tasks to respond to being cancelled      
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (InterruptedException ie) {
            // (Re-)Cancel if current thread also interrupted      
            pool.shutdownNow();      // Preserve interrupt status     
            Thread.currentThread().interrupt();
        }
    }

public interface ScheduledExecutorService extends ExecutorService {
    /**
     * 提交一個(gè)一次性任務(wù)，該任務(wù)在給定延遲后變?yōu)閱⒂脿顟B(tài)。
     *
     * @param command 要執(zhí)行的任務(wù)
     * @param delay 從現(xiàn)在開始延遲執(zhí)行的時(shí)間
     * @param unit delay參數(shù)的時(shí)間單位
     * @return 一個(gè)ScheduledFuture，標(biāo)識(shí)任務(wù)的掛起完成，其get方法將在完成時(shí)返回null
     */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);
    /**
     * 提交一個(gè)帶返回值的一次性任務(wù)，該任務(wù)在給定延遲后變?yōu)閱⒂脿顟B(tài)
     *
     * @param callable 要執(zhí)行的函數(shù)任務(wù)
     * @param delay 從現(xiàn)在開始延遲執(zhí)行的時(shí)間
     * @param unit delay參數(shù)的時(shí)間單位
     * @param <V> the type of the callable's result
     * @return 可用于提取結(jié)果或取消的ScheduledFuture
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);
    /**
     * 提交一個(gè)可執(zhí)行任務(wù)，延遲指定時(shí)間，然后按照period時(shí)間間隔執(zhí)行任務(wù)
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
    /**
     * 提交一個(gè)可執(zhí)行任務(wù)，延遲指定時(shí)間，然后按照period時(shí)間間隔執(zhí)行任務(wù)
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
}