invokeAny与执行快的任务异常

package Seven_invokeAny_Fast_Demo1;

import java.util.concurrent.Callable;

public class MyCallableA implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("MyCallableA" + Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
        for (int i = 0; i < 123; i++) {
            String newString = new String();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableA 在运行中= " + (i + 1));
        }

        if (1 == 1) {
            System.out.println("xxxxxxxxxxx=中断了");
            throw new NullPointerException();
        }

        System.out.println("MyCallableA" + Thread.currentThread().getName() + " end " + System.currentTimeMillis());

        return "return---A";
    }

}

package Seven_invokeAny_Fast_Demo1;

import java.util.concurrent.Callable;

public class MyCallableB implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("MyCallableB" + Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
        for (int i = 0; i < 223; i++) {
            String newString = new String();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableB 在运行中= " + (i + 1));
        }

        System.out.println("MyCallableB" + Thread.currentThread().getName() + " end " + System.currentTimeMillis());

        return "return---B";
    }

}

package Seven_invokeAny_Fast_Demo1;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Run {

    public static void main(String[] args) {
        try {

            List list = new ArrayList();

            list.add(new MyCallableB());
            list.add(new MyCallableA());

            ExecutorService service = Executors.newCachedThreadPool();

            String getString;

            getString = (String) service.invokeAny(list);
            System.out.println("main取得返回值=" + getString);
        } catch (InterruptedException e) {
            System.out.println("main Interrupted_Exception");
            e.printStackTrace();
        } catch (ExecutionException e) {
            System.out.println("main Execution_Exception");
            e.printStackTrace();
        }

    }

}

运行结果：

                                                                                                               

分析：

　　线程A是执行快的线程，线程B是执行慢的线程。线程A中断了，所以主线程中没有获取到A的返回值，线程A先执行完毕后，线程池将B设置为中断interrupte，但是线程B中没有对这个中断进行处理，所以线程B继续执行，不受影响。最终的结果是，线程B正常执行完毕，主线程中获取到线程B中return的值。

（2）倘若在执行快的线程A中，使用try_catch的方式对中断异常进行捕获

package Seven_invokeAny_Fast_Demo1;

import java.util.concurrent.Callable;

public class MyCallableA implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("MyCallableA" + Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
        
        try{
        for (int i = 0; i < 123; i++) {
            String newString = new String();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableA 在运行中= " + (i + 1));
        }

        if (1 == 1) {
            System.out.println("xxxxxxxxxxx=中断了");
            throw new NullPointerException();
        }

        System.out.println("MyCallableA" + Thread.currentThread().getName() + " end " + System.currentTimeMillis());
        }catch(Exception e){
            System.out.println(e.getMessage()+" : 左边信息就是捕获的异常信息");
        }

        return "return---A";
    }

}

运行结果：

                                                  

 

分析：

　　在A中进行了try_catch捕获中断异常，但是没有进行重新抛出异常。所带来的结果就是，主线程main获取到的不是没有异常的B线程的返回值，而是有中断异常的A线程的返回值。

　　这是因为，A线程虽然有中断异常，但是用try_cathch捕获后却没有重新抛出异常。导致主线程main误认为线程A是正确的，所以主线程main正常获取A的返回值，至于线程B，因为没有 对invokeAny()获取到第一个值（线程A的返回值）后调用的interrupt()方法发出的中断进行处理，所以线程B正常运行,只是最终主线程不获取线程B的返回值而已（因为之前主线程已经获取了线程A的返回值）。

（3）在线程A中，使用try_catch捕获中断异常后又重新抛出

package Seven_invokeAny_Fast_Demo1;

import java.util.concurrent.Callable;

public class MyCallableA implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println("MyCallableA" + Thread.currentThread().getName() + " begin " + System.currentTimeMillis());
        
        try{
        for (int i = 0; i < 123; i++) {
            String newString = new String();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            Math.random();
            System.out.println("MyCallableA 在运行中= " + (i + 1));
        }

        if (1 == 1) {
            System.out.println("xxxxxxxxxxx=中断了");
            throw new NullPointerException();
        }

        System.out.println("MyCallableA" + Thread.currentThread().getName() + " end " + System.currentTimeMillis());
        }catch(Exception e){
            System.out.println(e.getMessage()+" : 左边信息就是捕获的异常信息");
            
            throw e;//重新抛出异常
        }

        return "return---A";
    }

}

 

 

运行结果：

                                         

分析：

　　可以看到线程A通过try_catch捕获到中断异常，有采用 throw e将这个异常抛出，主线程main中就不会获得A的返回值，而是获得B的返回值