05-案例实现

案例实现

根据如下步骤来实现本案例。

1．实现一个任务并提交执行。创建一个名为 Task 的类，并实现 Runnable 接口：

public class Task implements Runnable {

2．声明一个名为 initDate 的 Date 类型的属性来存储任务的创建时间；并声明一个名为 name 的 String 类型的属性来存储任务的名称：

private final Date initDate;
private final String name;

3．实现该类的构造方法,并初始化全部属性：

public Task(String name) {
  initDate=new Date();
  this.name=name;
}

4．实现 run() 方法：

@Override
public void run() {

5．打印 initDate 的值和执行当前任务时的真正时间：

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

6．让当前任务随机休眠一段时间：

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

7．在控制台打印任务的完成时间：

System.out.printf("%s: Task %s Finished on: %s\n",
                  Thread.currentThread().getName(),name,
                  new Date());

8．创建一个名为 RejectedTaskController 的类，并实现 RejectedExecution- Handler 接口。在类中实现接口的 rejectedExecution() 方法，然后打印出被拒绝的任务名称和执行器的名称与状态：

public class RejectedTaskController implements
                                      RejectedExecutionHandler {
  @Override
  public void rejectedExecution(Runnable r,
                                ThreadPoolExecutor executor) {
    System.out.printf("RejectedTaskController: The task %s has been
                      rejected\n",r.toString());
    System.out.printf("RejectedTaskController: %s\n",
                      executor.toString());
    System.out.printf("RejectedTaskController: Terminating: %s\n",
                      executor.isTerminating());
    System.out.printf("RejectedTaskController: Terminated: %s\n",
                      executor.isTerminated());
  }

9．创建一个 Server 类，用一个 executor 实例对象来执行它收到的每一个任务：

public class Server {

10．声明一个名为 executor 、类型为 ThreadPoolExecutor 的属性：

private final ThreadPoolExecutor executor;

11．实现这个类的构造方法，用 Executors 类来初始化 ThreadPoolExecutor 对象，并创建一个拒绝策略：

public Server(){
  executor =( ThreadPoolExecutor ) Executors.newFixedThreadPool(
                Runtime.getRuntime().availableProcessors() );
  RejectedTaskController controller=new
                                 RejectedTaskController();
  executor.setRejectedExecutionHandler(controller);
}

12．实现 executeTask() 方法来接收一个 Task 对象作为参数，并将其提交给一个执行器。首先，在控制台打印信息来表明一个新任务已经到达：

public void executeTask(Task task) {
  System.out.printf("Server: A new task hash arrived\n");

13．调用执行器的 execute() 方法来提交任务：

executor.execute(task);

14．在控制台打印执行器的信息来区分状态：

System.out.printf("Server: Pool Size: %d\n",
                  executor.getPoolSize());
System.out.printf("Server: Active Count: %d\n",
                  executor.getActiveCount());
System.out.printf("Server: Task Count: %d\n",
                  executor.getTaskCount());
System.out.printf("Server: Completed Tasks: %d\n",
                  executor.getCompletedTaskCount());

15．实现 endServer() 方法。在这个方法中，调用执行器的 shutdown() 方法来终止执行器：

public void endServer() {
  executor.shutdown();
}

16．至此，我们可以开始实现应用程序的入口，创建包含 main() 方法的 Main 类。首先，创建100个任务并将其提交给 Executor ：

public class Main {
  public static void main(String[] args) {
    Server server=new Server();
    System.out.printf("Main: Starting.\n");
      for (int i=0; i<100; i++){
        Task task=new Task("Task "+i);
        server.executeTask(task);
      }

17．调用 Server 类中的 endServer() 方法来终止执行器：

System.out.printf("Main: Shuting down the Executor.\n");
server.endServer();

18．提交一个新的任务。由于这个任务会被拒绝，因此我们可以看到拒绝策略是如何生效的：

System.out.printf("Main: Sending another Task.\n");
Task task=new Task("Rejected task");
server.executeTask(task);
System.out.printf("Main: End.\n");