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，你将使系统超过负荷。