08-案例实现

案例实现

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

1．首先实现工作线程类。创建一个名为 AlwaysThrowsExceptionWorkerThread 的类，该类继承自 ForkJoinWorkerThread ：

public class AlwaysThrowsExceptionWorkerThread extends
                        ForkJoinWorkerThread {

2．实现该类的构造器。它接收一个 ForkJoinPool 对象作为构造参数，并用该参数调用其父构造器：

protected AlwaysThrowsExceptionWorkerThread(ForkJoinPool pool) {
    super(pool);
}

3．实现 onStart() 方法。它是 ForkJoinWorkerThread 类的方法，工作线程启动时会调用该方法。我们在其中抛出一个 RuntimeException ：

protected void onStart() {
  super.onStart();
  throw new RuntimeException("Exception from worker thread");
}

4．现在实现创建工作线程的工厂类。创建一个名为 AlwaysThrowsExceptionWorker- ThreadFactory 的类，实现 ForkJoinWorkerThreadFactory 接口：

public class AlwaysThrowsExceptionWorkerThreadFactory implements
                         ForkJoinWorkerThreadFactory {

5．实现 newThread() 方法。该方法接收 ForkJoinPool 对象作为参数，返回一个 ForkJoinWorkerThread 对象。创建并返回 AlwaysThrowsExceptionWorkerThread 类型对象 ：

@Override
public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
  return new AlwaysThrowsExceptionWorkerThread(pool);
}

6．实现一个类来管理工作线程抛出的异常。创建 Handler 并实现 UncaughtException- Handler 接口：

public class Handler implements UncaughtExceptionHandler {

7．实现 uncaughtException() 方法。每当工作线程抛出异常时， ForkJoinPool 都会调用该方法，它接收 Thread 对象和 Throwable 对象作为参数。它在该方法中打印一条信息后退出：

@Override
public void uncaughtException(Thread t, Throwable e) {
  System.out.printf("Handler: Thread %s has thrown an
                     Exception.\n",t.getName());
  System.out.printf("%s\n",e);
  System.exit(-1);
}

8．实现在 ForkJoinPool 中执行的任务。创建 OneSecondLongTask 类并继承 RecursiveAction ：

public class OneSecondLongTask extends RecursiveAction{

9．实现 compute() 方法，让线程休眠1s：

@Override
protected void compute() {
  System.out.printf("Task: Starting.\n");
  try {
    TimeUnit.SECONDS.sleep(1);
  } catch (InterruptedException e) {
    e.printStackTrace();
  }
  System.out.printf("Task: Finish.\n");
}

10．实现本案例的主类，创建一个包含 main() 方法的 Main 类：

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

11．新建一个 OneSecondLongTask 对象：

OneSecondLongTask task=new OneSecondLongTask();

12．新建一个 Handler 对象：

Handler handler = new Handler();

13．新建一个 AlwaysThrowsExceptionWorkerThreadFactory 对象：

AlwaysThrowsExceptionWorkerThreadFactory factory=new
                    AlwaysThrowsExceptionWorkerThreadFactory();

14．新建一个 ForkJoinPool 对象。将数字2、 factory 对象、 handler 对象和 false 传入其中：

ForkJoinPool pool=new ForkJoinPool(2,factory,handler,false);

15．在线程池上用 execute() 方法执行任务：

pool.execute(task);

16．用 shutdown() 方法关闭 pool ：

pool.shutdown();

17．用 awaitTermination() 方法等待任务的完成：

try {
  pool.awaitTermination(1, TimeUnit.DAYS);
} catch (InterruptedException e) {
  e.printStackTrace();
}

18．打印程序结束信息：

System.out.printf("Task: Finish.\n");