Java并发编程之线程管理（Executor框架11）

4线程执行器

如果你不得不开发一个需要运行许多并发任务的程序，这种方法有下面这些劣势：

Ø  你不得不实现所有相关代码来管理线程对象（对象的创建，结束，获取结果）。

Ø  每个任务，你需要创建一个线程。如果你不得不执行一个超大量的任务，这将影响到应用程序的吞吐量。处理不好，会影响系统的整体性能。

Ø  你不得不高效地控制和管理计算机的系统资源。如果你创建了太对的线程，你的系统资源会变得不到充分利用。

从Java 5以后，Java 并发API提供了一个机制来解决这些问题。这个机制是称作执行器框架（Executor Framework）,它围绕着接口Executor，它的子接口ExecutorService,类ThreadPoolExecutor实现了这两个接口。

使用一个executor，你仅需要实现Runnable，并发送给executor对象。Executor对象负责执行，实例化，和运行必要的线程。它的功能远不止这些，它使用线程池帮助提高了系统的性能。运用线程池，避免了连续不断的产生线程的花费，这样合理利用了系统资源。另外，Executor框架是一个callable接口，调用call方法可以返回执行结果。同时，你将获得一个实现了Future接口的对象，使用这个对象来控制线程的状态和Callable对象的返回值。

1.1   创建一个线程执行器

使用Executor 框架的第一步骤就是创建一个ThreadPoolExecutor类，你能够使用四个参数的构造方法或者使用一个叫做Executors工厂类来创建ThreadPoolExecutor对象。一旦你有一个executor对象，你可以发送Runnable或者Callable对象，执行对应的业务逻辑。

看一个例子，首先创建一个Task类，实现所需要执行的业务逻辑。

 

import java.util.Date;import java.util.concurrent.TimeUnit; /** * This class implements aconcurrent task * */public class Task implements Runnable {     /**     * The start date of the task     */    private Date initDate;    /**     * The name of the task     */    private String name;       /**     * Constructor of the class. Initializes thename of the task     * @param name name asigned to the task     */    public Task(String name){        initDate=new Date();        this.name=name;    }       /**     * This method implements the execution of thetask. Waits a random period of time and finish     */    @Override    public voidrun() {        System.out.printf("%s: Task %s: Created on: %s\n",Thread.currentThread().getName(),name,initDate);        System.out.printf("%s: Task %s: Started on: %s\n",Thread.currentThread().getName(),name,new Date());               try {            Long duration=(long)(Math.random()*10);            System.out.printf("%s: Task %s: Doing a task during %d seconds\n",                              Thread.currentThread().getName(),                              name,                              duration);            TimeUnit.SECONDS.sleep(duration);        } catch (InterruptedException e) {            e.printStackTrace();        }               System.out.printf("%s: Task %s: Finished on: %s\n",Thread.currentThread().getName(),name,new Date());    } } 

创建Worker类，定义自己的线程池执行器，管理线程的执行情况。

 

import java.util.concurrent.Executors;importjava.util.concurrent.ThreadPoolExecutor; public class Worker {     /*ThreadPoolExecutorsto manage the execution of the request */    private ThreadPoolExecutor executor;       public Worker(){        executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();    }          /**     * This method is called when a request to theserver is made. The     * server uses the executor to execute therequest that it receives     * @param task The request made to the server     */    public voidexecuteTask(Task task){        System.out.printf("Server: A new task has arrived\n");        executor.execute(task);        System.out.printf("Server: Pool Size: %d\n",executor.getPoolSize());        System.out.printf("Server: Active Count: %d\n",executor.getActiveCount());        System.out.printf("Server: Completed Tasks: %d\n",executor.getCompletedTaskCount());    }       /**     * Ends the task with shutdown() method.     */    public voidendTask(){        executor.shutdown();    }       public staticvoidmain(String []args){               Worker worker = new Worker();               for(int i = 0; i < 100; i++){            Task task = new Task("task_"+ i);            worker.executeTask(task);        }           }}

在这个例子中，你通过使用newCachedThreadPool()方法创建了一个缓存线程池。这个方法返回一个ExecutorService对象。因此，它被强制转换成ThreadPoolExecutor。如果缓存的线程池需要去执行一个新任务时，它将使用那些已经运行完的线程来执行新线程的任务。线程的重新利用，有利于减少创建新线程的时间，这是它的优势所在。然而，它的劣势就是总存在为新任务准备的常量线程，这样的话，如果你发送大量的任务给executor，你将使系统超过负荷。