并发编程6-执行器

来源：互联网发布：石家庄程序员工资编辑：程序博客网时间：2024/06/06 05:55

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

现在看一个服务器应用：

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);        }    }

Exccutors.可以创建多个策略的执行器。 newFixedThreadPool是可以运行指定书目的执行器。

这个是一个生产者和消费者模式， 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();            }        }    }}

定时执行

Timer 和TimerTask

使用简单，但是是点线程调度，并且任务如果抛出异常，会影响其他任务

ScheduleThreadPoolExecutor 1.5之后更好的调度执行器

可携带结果的任务Callable 和 Future

public class TestCallable {    public static void main(String[] args) {        List<Future<Integer>> futureList = new ArrayList<Future<Integer>>();        ExecutorService executor = Executors.newFixedThreadPool(3);                for (int i = 0; i < 5; i++) {            futureList.add(executor.submit(new AddCallable(i, i + 1)));        }        for (Future<Integer> future : futureList) {            try {                System.out.println(future.get());            } catch (InterruptedException e) {                e.printStackTrace();            } catch (ExecutionException e) {                e.printStackTrace();            }        }    }}class AddCallable implements Callable<Integer>{    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;    }}

ExecutorService submit Callable进去。返回Future, get()会阻塞到执行结果或者抛出异常，如果抛出ExecutionException则可以使用getCause得到异常链。

如果第一个任务比第二个任务执行的时间长，则可能造成不能及时获取到返回结果。可以使用get(0)不停地试探，但是可以使用更好的方式使用自带阻塞队列的ExecutorCompletionService中

 public static void main(String[] args) throws InterruptedException, ExecutionException {        ExecutorService executor = Executors.newFixedThreadPool(3);        CompletionService<String> serv =                new ExecutorCompletionService<String>(executor);        serv.submit(new Callable<String>() {            @Override            public String call() throws Exception {                TimeUnit.SECONDS.sleep(3);                return "第一个任务执行完";            }        });        serv.submit(new Callable<String>() {            @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();    }

0 0