ExecutorService线程池管理

public class inter {
    /**
     * 启动单个线程，顺序执行
     */

    public void SingleThread() {
        ExecutorService es = Executors.newSingleThreadExecutor();
        es.execute(new Runnable() {
            public void run() {
                System.out.println("启动single线程="
                        + Thread.currentThread().getName());
            }
        });
        es.execute(new Runnable() {

            @Override
            public void run() {
                System.out.println("再次启动single线程=="
                        + Thread.currentThread().getName());
            }
        });
    }

    /**
     * 根据任务量启动线程数量
     */
    public void AllThread() {
        ExecutorService es = Executors.newCachedThreadPool();
        for (int i = 0; i < 4; i++) {
            final int t = i;
            es.execute(new Runnable() {

                @Override
                public void run() {
                    while (true) {
                        System.out.println("当前线程是："
                                + Thread.currentThread().getName() + "当前 i ："
                                + t);
                        try {
                            Thread.sleep(1000 * 60);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    /**
     * 确定线程数量
     */
    public void FixedThread() {
        ExecutorService es = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 4; i++) {
            final int t = i;
            es.execute(new Runnable() {

                @Override
                public void run() {
                    while (true) {
                        System.out.println("当前线程是："
                                + Thread.currentThread().getName() + "当前 i ："
                                + t);
                        try {
                            Thread.sleep(1000 * 3);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        if (2 == t) {
                            return;
                        }
                    }
                }
            });
        }
    }

    /**
     * 带返回值的callback
     * 
     * @return
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public String Call() throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newCachedThreadPool();
        ArrayList<Future<String>> future = new ArrayList<Future<String>>();
        for (int j = 0; j < 100; j++) {
            // 带着参数j去的，所以以后可以换成图片的地址什么的
            future.add(es.submit(new MyCall(j)));
        }
        System.out.println("ca");
        System.out.println(future.size());
        for (Future<String> fu : future) {
            System.out.println("返回值：" + fu.get());
        }
        return null;

    }

    // 用于获取返回值的
    class MyCall implements Callable<String> {
        private int sql;

        public MyCall(int i) {
            // TODO Auto-generated constructor stub
            this.sql = i;
        }

        @Override
        public String call() throws Exception {
            // TODO Auto-generated method stub
            System.out.println("执行" + sql + ","
                    + Thread.currentThread().getName());
            System.out.println("Weak Up" + sql);
            return "完成" + sql;
        }

    }
}

下面给出了一个网络服务的简单结构，这里线程池中的线程作为传入的请求。它使用了预先配置的 Executors.newFixedThreadPool(int) 工厂方法： 
 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
    }
 }

下列方法分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务，然后调用 shutdownNow（如有必要）取消所有遗留的任务： 
 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();
   }
 }

其中实现Runnable和Callable不同的是，前者没有返回值，后者有。