多线程（二）

主要的说明承接上面的InvokeAny/All 的说明，主要是代码的说明，接下来会对源码的说明：

import java.util.concurrent.Callable;

/*
 * 这是一个可能会在执行过程中，抛出空指针异常的任务。
 * */
public class ExceptionCallable implements Callable<String> {
    private String name = null;

    public ExceptionCallable() {
    }

    public ExceptionCallable(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        System.out.println("begin to ExceptionCallable.");
        System.out.println(name.length());
        System.out.println("end to ExceptionCallable.");
        return name;
    }
}

import java.util.Random;
import java.util.concurrent.Callable;

//短时任务，随即按产生10个数字
public class RandomTenCharsTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("RandomTenCharsTask begin to execute...");
        StringBuffer content = new StringBuffer();
        String base = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int number = random.nextInt(base.length());
            content.append(base.charAt(number));
        }
        System.out.println("RandomTenCharsTask complete.result=" + content);
        return content.toString();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
/**
 * 这是一个通过睡眠来模拟的耗时任务，该任务是可中断/可终止的任务，能够响应中断请求。
 * */

public class SleepSecondsCallable implements Callable<String> {
    private String name;
    private int seconds;

    public SleepSecondsCallable(String name, int seconds) {
        this.name = name;
        this.seconds = seconds;
    }

    public String call() throws Exception {
        System.out.println(name + ",begin to execute");
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            System.out.println(name + " was disturbed during sleeping.");
            e.printStackTrace();
            return name + "_SleepSecondsCallable_failed";
        }
        System.out.println(name + ",success to execute");
        return name + "_SleepSecondsCallable_succes";
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class Snippet {
    
    public static void main(String[] args) throws Exception{
//        invokeAny1();
        invokeAny2();
    }
    
    /**
     * 提交的任务集合,一旦有1个任务正常完成(没有抛出异常),会终止其他未完成的任务
     * 此方法中输出是：
     */
    public static void invokeAny1() throws Exception
    {
      ExecutorService executorService = Executors.newFixedThreadPool(3);
      List<Callable<String>> tasks = new ArrayList<Callable<String>>();
      tasks.add(new SleepSecondsCallable("t1", 2));
      tasks.add(new SleepSecondsCallable("t2", 1));
      String result = executorService.invokeAny(tasks);
      System.out.println("result=" + result);
      executorService.shutdown();
    }

    /* 此invokeAny1()方法的输出结果：
     * t2,begin to execute
     * t1,begin to execute
     * t2,success to execute
     * java.lang.InterruptedException: sleep interrupted
     * result=t2_SleepSecondsCallable_succes
     * t1 was disturbed during sleeping.
     * 一个任务执行完成以后，会终止其他未完成的任务
     */
    
    /**
    * 没有1个正常完成的任务,invokeAny()方法抛出ExecutionException,
    * 封装了任务中元素的异常
    */
    public static void invokeAny2() throws Exception
    {
      ExecutorService executorService = Executors.newFixedThreadPool(3);
      List<Callable<String>> tasks = new ArrayList<Callable<String>>();
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      String result = executorService.invokeAny(tasks);
      System.out.println("result=" + result);
      executorService.shutdown();
    }
    /*invokeAny2()执行的结果：
     * begin to ExceptionCallable.
     * begin to ExceptionCallable.
     * begin to ExceptionCallable.
     * Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.NullPointerException
     * 具体的那个线程抛出来的错误，就无所谓了。
     * /
    
    /**
    * 有异常的任务,有正常的任务,invokeAny()不会抛异常,返回最先正常完成的任务
    */
    public static void invokeAny3() throws Exception
    {
      ExecutorService executorService = Executors.newFixedThreadPool(3);
      List<Callable<String>> tasks = new ArrayList<Callable<String>>();
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new SleepSecondsCallable("t1", 2));
      String result = executorService.invokeAny(tasks);
      System.out.println("result=" + result);
      executorService.shutdown();
    }

    /**
     * 还没有到超时之前,所以的任务都已经异常完成,抛出ExecutionException<br>
     * 如果超时前满,还没有没有完成的任务,抛TimeoutException
     */
    public static void invokeAnyTimeout() throws Exception
    {
      ExecutorService executorService = Executors.newFixedThreadPool(3);
      List<Callable<String>> tasks = new ArrayList<Callable<String>>();
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      tasks.add(new ExceptionCallable());
      String result = executorService.invokeAny(tasks, 2, TimeUnit.SECONDS);
      System.out.println("result=" + result);
      executorService.shutdown();
    }

    /*
     * 测试invokeAll
     * */
    public static void testInvokeAll() throws Exception
    {
      ExecutorService executorService = Executors.newFixedThreadPool(5);
      List<Callable<String>> tasks = new ArrayList<Callable<String>>();
      tasks.add(new SleepSecondsCallable("t1", 2));
      tasks.add(new SleepSecondsCallable("t2", 2));
      tasks.add(new RandomTenCharsTask());
      tasks.add(new ExceptionCallable());
      // 调用该方法的线程会阻塞,直到tasks全部执行完成(正常完成/异常退出)
      List<Future<String>> results = executorService.invokeAll(tasks);
      // 任务列表中所有任务执行完毕,才能执行该语句
      System.out.println("wait for the result." + results.size());
      executorService.shutdown();
      for (Future<String> f : results)
      {
        // isCanceled=false,isDone=true
        System.out.println("isCanceled=" + f.isCancelled() + ",isDone="
            + f.isDone());
        // ExceptionCallable任务会报ExecutionException
        System.out.println("task result=" + f.get());
      }
    }

}