如果想开发服务器应用，应该有大的吞吐量和快速的响应。  这样就要求服务器段有清晰的任务边界和任务执行策略。

现在看一个服务器应用：

public static void main(String[] args) throws IOException {        ServerSocket ss = new ServerSocket(8080);        while (true){            Socket s = ss.accept();            handleRequest(s);        }    }

来一个多线程的：

public static void main(String[] args) throws IOException {        ServerSocket ss = new ServerSocket(8080);        while (true){            final Socket s = ss.accept();            new Thread(){                @Override                public void run() {                    handleRequest(s);                }            }.start();        }    }

但是因为程序并发，可能要注意资源冲突。

另外其还会造成线程无线增长带来的栈溢出，内存溢出， 创建线程的开销过大等问题。

更好的办法是，能够平缓的进行优化，就是能够更好的调度任务，控制线程的个数等等。这就需要用到Executor框架

先来个固定线程数的：

public static void main(String[] args) throws IOException {        final Executor exec = Executors.newFixedThreadPool(3);        ServerSocket ss = new ServerSocket(8080);        while (true){            final Socket s = ss.accept();            Runnable task = new Runnable(){                @Override                public void run() {                    handleRequest(s);                }            };            exec.execute(task);        }    }

这个是一个生产者和消费者模式，  exec.execute是生产,  FixedThreadPool表示有空闲的线程就能消费这个task.

任务策略

Executor是用一个策略来执行任务，那么策略应该决定线程的那些行为呢：

• 任务在什么线程中执行
• 任务以什么顺序执行(FIFO, 优先级？)
• 可以有多少个任务并发执行
• 可以有多少个任务进入等待队列
• 如果要舍弃一个任务，如何选择，并且如何告诉应用程序
• 在执行任务前后应该做什么

生命周期

ExecutorService。 这个接口包含了很多生命周期的方法：

shutdown()  停止接收新任务，  等待已提交任务的完成，  再次想加入新任务会抛出RejectedExecutionException

shutdownNom  停止为执行的任务，并且尝试关闭正在运行的任务

awaitTermination等待到达终止状态，跟轮询判断isTrminated的效果一样。通常shutdown会紧随其后，进入种植状态后就关闭Executor

isShutdown 判断是否关闭

isTermination 判断是否进入终止状态：

例如可关闭的Server:

public class WebServer {    private static final ExecutorService exec = Executors.newFixedThreadPool(1);    public static void main(String[] args) throws IOException {        ServerSocket ss = new ServerSocket(8080);        new Thread(){            @Override            public void run() {                while(!exec.isTerminated()){                }                System.exit(0);            }        }.start();        while (true){            final Socket s = ss.accept();            Runnable task = new Runnable(){                @Override                public void run() {                    handleRequest(s);                }            };            exec.execute(task);        }    }    private static void handleRequest(Socket s) {        BufferedReader is = null;        try {            is = new BufferedReader(new InputStreamReader(s.getInputStream()));            String line = is.readLine();            if("exit".equals(line)){                System.out.println("进来了");                exec.shutdown();            }            System.out.println(line);        } catch (IOException e) {            e.printStackTrace();        } finally {            try {                is.close();                s.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

定时执行

可携带结果的任务Callable 和 Future

public class TestCallable {    public static void main(String[] args) {        List
     
      
       > futureList = new ArrayList
       
        
         >();        ExecutorService executor = Executors.newFixedThreadPool(3);                for (int i = 0; i < 5; i++) {            futureList.add(executor.submit(new AddCallable(i, i + 1)));        }        for (Future
         
           future : futureList) {            try {                System.out.println(future.get());            } catch (InterruptedException e) {                e.printStackTrace();            } catch (ExecutionException e) {                e.printStackTrace();            }        }    }}class AddCallable implements Callable
          
           { private int param1; private int param2; public AddCallable(int param1, int param2) { this.param1 = param1; this.param2 = param2; } @Override public Integer call() throws Exception { return param1 + param2; }}
          
         
        
       
      
     

public static void main(String[] args) throws InterruptedException, ExecutionException {        ExecutorService executor = Executors.newFixedThreadPool(3);        CompletionService
    
      serv =                new ExecutorCompletionService
     
      (executor);        serv.submit(new Callable
      
       () {            @Override            public String call() throws Exception {                TimeUnit.SECONDS.sleep(3);                return "第一个任务执行完";            }        });        serv.submit(new Callable
       
        () {            @Override            public String call() throws Exception {                TimeUnit.SECONDS.sleep(1);                return "第二个任务执行完";            }        });        for (int i = 0; i < 2; i++) {            System.out.println(serv.take().get());        }        executor.shutdown();    }