java线程池执行器_Java并发编程高级篇(一)：使用线程池执行器

使用执行器框架(Executor Framework)的第一步是创建执行器ThreadPoolExecutor对象。我们可以使用ThreadPoolExecutor提供的四个构造函数，或者使用Executors工厂方法来创建线程执行器。一旦有了执行器，我们就可以把Runnable或Callable对象发送给它去执行了。

接下来我们使用执行器来实现一个能够处理客户端请求的服务器。

首先我们创建一个任务执行线程，这个线程用来模拟处理客户端的请求任务，它首先打印线程创建和启动时间，然后随机休眠一段时间用来模拟任务处理过程，最后打印任务结束时间。

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.TimeUnit;

/**

* 任务执行类

* Created by hadoop on 15/12/9.

*/

public class Task implements Runnable{

private String name;

private Date initDate;

public Task(String name) {

this.name = name;

this.initDate = new Date();

}

/**

* 任务过程

* 1. 打印任务创建时间

* 2. 打印任务开始时间

* 3. 任务随机休眠一段时间

* 4. 打印任务结束时间

*/

@Override

public void run() {

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.printf("%s: Task %s: Created on: %s\n",

Thread.currentThread().getName(), name, format.format(initDate));

System.out.printf("%s: Task %s: Started on: %s\n",

Thread.currentThread().getName(), name, format.format(new Date()));

long duration = (long)(Math.random() * 10);

System.out.printf("%s: Task %s: Do something duration %d Seconds\n",

Thread.currentThread().getName(), name, duration);

try {

TimeUnit.SECONDS.sleep(duration);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.printf("%s: Task %s: Finished on: %s\n",

Thread.currentThread().getName(), name, format.format(new Date()));

}

}

接下来我们创建服务端Server类，用来模拟接受客户端的请求，然后启动任务线程来处理请求，在这个类中，我们是用来线程处理器ThreadPoolExecutor。在这里我们使用了Executors.newCachedThreadPool()线程执行器工厂来创建线程执行器，这个方法会返回一个ExecutorService类型的对象，因此需要将它的类型转换为ThreadPoolExecutor类型。

如果需要执行任务，那么线程池执行器就会创建一个新的线程来执行这个任务，如果任务执行完毕，线程池会回收线程，当有新的任务进来的时候，将会从线程池中获取线程来执行这个任务。当然如果一次发送过多的任务给线程执行器，那么将会造成很高的系统负载。

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadPoolExecutor;

/**

* 任务调度类

* 1. 启动一个线程池：(ThreadPoolExecutor) Executors.newCachedThreadPool();

* 2. 接受任务并加入到线程池中

* 3. 所有任务之行结束后关闭线程池

* Created by hadoop on 15/12/9.

*/

public class Server {

ThreadPoolExecutor executor;

public Server() {

executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();

}

/**

* 执行任务并打印当前线程池状态

* @param task 任务

*/

public void execute(Task task) {

System.out.println("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 Task: %d\n", executor.getCompletedTaskCount());

}

public void endServer() {

executor.shutdown();

}

}

最后创建主类Main，并运行程序。

public class Main {

/**

* 创建10个任务并发送到线程池中

* @param args

* @throws InterruptedException

*/

public static void main(String[] args) throws InterruptedException {

Server server = new Server();

for (int i = 0; i < 10; i++) {

Task task = new Task("Task" + i);

server.execute(task);

Thread.sleep(1000);

}

server.endServer();

}

}