27-案例实现

案例实现

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

1．创建一个名为 TaskFJ 的类，它继承 RecursiveAction 类：

public class TaskFJ extends RecursiveAction {

2．声明一个私有的整型数组属性，并将其命名为 array ：

private final int array[];

3．声明两个私有的整型属性，并将它们分别命名为 start 和 end ：

private final int start, end;

4．实现该类的构造器并初始化这些属性：

public TaskFJ(int array[], int start, int end) {
  this.array=array;
  this.start=start;
  this.end=end;
}

5．实现 compute() 方法。如果该任务要处理的元素数量大于1000个（数量由 start 和 end 决定），那么就创建两个 TaskFJ 对象，使用 fork() 方法将它们发送给 ForkJoinPool ，并使用 join() 方法等待它们的结束：

@Override
protected void compute() {
  if (end-start>1000) {
    int mid=(start+end)/2;
    TaskFJ task1=new TaskFJ(array,start,mid);
    TaskFJ task2=new TaskFJ(array,mid,end);
    task1.fork();
    task2.fork();
    task1.join();
    task2.join();

6．否则，递增该任务要处理的元素。每次递增之后，让线程休眠1ms：

} else {
  for (int i=start; i<end; i++) {
    array[i]++;
    try {
      TimeUnit.MILLISECONDS.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

7．创建一个实现 Runnable 接口的类，并将其命名为 Task ：

public class Task implements Runnable {

8．声明一个私有的整型数组属性，并将其命名为 array ：

private final int array[];

9．实现该类的构造器来初始化这些属性：

public Task(int array[]) {
  this.array=array;
}

10．实现 run() 方法。递增数组中所有的元素。在每次递增之后，让线程休眠1ms：

@Override
public void run() {
  for (int i=0; i<array.length; i++ ){
    array[i]++;
    try {
      TimeUnit.MILLISECONDS.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}

11．实现本案例的主类，创建一个 Main 并添加 main() 方法：

public class Main {
  public static void main(String[] args) {

12．创建一个有100000个元素的 int 型数组：

int array[]=new int[100000];

13．创建 Task 和 ThreadPoolExecutor 对象并执行它们。打印运行任务花费的时间：

Task task=new Task(array);
ExecutorService executor=Executors.newCachedThreadPool();
Date start,end;
start=new Date();
executor.execute(task);
executor.shutdown();
try {
  executor.awaitTermination(1, TimeUnit.DAYS);
} catch (InterruptedException e) {
  e.printStackTrace();
}
end=new Date();
System.out.printf("Main: Executor: %d\n",
                  (end.getTime()-start.getTime()));

14．创建 TaskFJ 和 ForkJoinPool 对象并执行它们。打印运行任务花费的时间：

  TaskFJ taskFJ=new TaskFJ(array,1,100000);
  ForkJoinPool pool=new ForkJoinPool();
  start=new Date();
  pool.execute(taskFJ);
  pool.shutdown();
  try {
    pool.awaitTermination(1, TimeUnit.DAYS);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  end=new Date();
  System.out.printf("Core: Fork/Join: %d\n",
                    (end.getTime()-start.getTime()));
}