一、此方法获得最先完成任务的结果，即Callable<T>接口中的call的返回值，在获得结果时，会中断其他正在执行的任务
示例代码:
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class MyinvokeAny {
public static void main(String[] args) {
// TODO 自动生成的方法存根
List<Callable<String>> list=new ArrayList<Callable<String>>();
list.add(new MyCallable_iAny1());
list.add(new MyCallable_iAny2());
ExecutorService executor=Executors.newCachedThreadPool();
try {
String str=executor.invokeAny(list);//取出第一个执行完的任务时，其他未完成的任务会被中断
System.out.println(str);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (ExecutionException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
class MyCallable_iAny1 implements Callable<String>{
@Override
public String call() throws Exception {
// TODO 自动生成的方法存根
try{
for(int i=0;i<123456;i++){
for(int j=0;j<123;j++){
if(Thread.currentThread().isInterrupted()){
System.out.println("this is a exception");
throw new InterruptedException("A InterruptedException");
}
}
}
}catch(Exception e){
e.printStackTrace();
throw e;
}
System.out.println("finish");
return "call_1";
}
}
class MyCallable_iAny2 implements Callable<String>{
@Override
public String call() throws Exception {
// TODO 自动生成的方法存根
Thread.sleep(1000);
return "call_2";
}
}
运行结果：
call_2java.lang.InterruptedException: A InterruptedException this is a exception at myexecutorservice.MyCallable_iAny1.call(myinvokeAny.java:53) at myexecutorservice.MyCallable_iAny1.call(myinvokeAny.java:1) at java.util.concurrent.FutureTask.run(Unknown Source)
二、异常的处理
对于会先完成，但会出现异常的任务，ExecutorService会将关注点换到下一个任务，若果所有的任务都出现异常，那么将会只获得最后一个任务的异常（例如，有3个任务A,B,C，这三个任务都会出现异常，但是只会获得C任务的异常）
示例代码：
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class myinvokeAny {
public static void main(String[] args) {
// TODO 自动生成的方法存根
List<Callable<String>> list=new ArrayList<Callable<String>>();
list.add(new MyCallable_iAny1());
list.add(new MyCallable_iAny2());
ExecutorService executor=Executors.newCachedThreadPool();
try {
String str=executor.invokeAny(list);//取出第一个执行完的任务时，其他未完成的任务会被中断
System.out.println(str);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} catch (ExecutionException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
class MyCallable_iAny1 implements Callable<String>{
@Override
public String call() throws Exception {
// TODO 自动生成的方法存根
Thread.sleep(2000);
System.out.println("finish");
return "call_1";
}
}
class MyCallable_iAny2 implements Callable<String>{
@Override
public String call() throws Exception {
// TODO 自动生成的方法存根
Thread.sleep(1000);
if(true){
throw new Exception("myException_B");
}
return "call_2";
}
}
运行结果：
finish call_1
由此，我们可以看出，MyCallable_iAny2任务出现异常，从而将任务的关注点移到了MyCallable_iAny1任务，并不会打印出异常信息。如果，想打印出异常信息，需要这样写：
写法一：
try{
if(true){
throw new Exception("myException_B");
}
}catch(Exception e){
e.printStackTrace();
}
运行结果：
java.lang.Exception: myException_B call_2 at myexecutorservice.MyCallable_iAny2.call(myinvokeAny.java:76) at myexecutorservice.MyCallable_iAny2.call(myinvokeAny.java:1)
这里获得了异常任务的结果，这是因为MyCallable_iAny2的异常状态未上报，这导致线程池认为其是正确的，从而未将关注点换到下一个任务
写法二：
try{
if(true){
throw new Exception("myException_B");
}
}catch(Exception e){
// e.printStackTrace();
throw e;
}
运行结果：
finish call_1
这里抛出了异常，从了线程池将关注点换到了下一个任务