（原创）Callable、FutureTask中阻塞超时返回的坑点

直接上代码

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {

    private long waitTime;

    public MyCallable(int timeInMillis){
        this.waitTime=timeInMillis;
    }
    @Override
    public String call() throws Exception {
        Thread.sleep(waitTime);
        return Thread.currentThread().getName();
    }

}

结果阻塞的代码

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureTaskExample {

    public static void main(String[] args) {
        MyCallable callable1 = new MyCallable();
        MyCallable callable2 = new MyCallable();

        FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
        FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

        ExecutorService executor = Executors.newFixedThreadPool();
        executor.execute(futureTask1);
        executor.execute(futureTask2);

        while (true)
        {
            try {
                if(futureTask1.isDone() && futureTask2.isDone()){
                    System.out.println("Done");
                    //shut down executor service
                    executor.shutdown();
                    return;
                }

                if(!futureTask1.isDone()){
                //阻塞futureTask1
                System.out.println("FutureTask1 output="+futureTask1.get());
                }

                if(!futureTask2.isDone()){
                //阻塞futureTask2
                System.out.println("FutureTask2 output="+futureTask2.get());
                }

            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }catch(Exception e){
                //do nothing
            }
        }

    }

}

运行结果很简单，必须是：

FutureTask1 output=pool-1-thread-1
FutureTask2 output=pool-1-thread-2
Done

如果改为阻塞超时，先猜猜输出结果是什么。注意第37行代码有超时处理。

 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;

 public class FutureTaskExample {

     public static void main(String[] args) {
         MyCallable callable1 = new MyCallable();
         MyCallable callable2 = new MyCallable();

         FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
         FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

         ExecutorService executor = Executors.newFixedThreadPool();
         executor.execute(futureTask1);
         executor.execute(futureTask2);

         while (true)
         {
             try {
                 if(futureTask1.isDone() && futureTask2.isDone()){
                     System.out.println("Done");
                     //shut down executor service
                     executor.shutdown();
                     return;
                 }

                 if(!futureTask1.isDone()){
                 //阻塞futureTask1
                 System.out.println("FutureTask1 output="+futureTask1.get());
                 }

                 System.out.println("Waiting for FutureTask2 to complete");
                 String s = futureTask2.get(500L, TimeUnit.MILLISECONDS); //阻塞500毫秒
                 if(s !=null){
                     System.out.println("FutureTask2 output="+s);
                 }
                 else{
                     System.out.println("FutureTask2 output is null");
                 }
             } catch (InterruptedException | ExecutionException e) {
                 e.printStackTrace();
             }catch(Exception e){
                 //do nothing
             }
         }

     }

 }

如果说是这样的结果，那就错了

FutureTask1 output=pool-1-thread-1
Waiting for FutureTask2 to complete
FutureTask2 output is null
Waiting for FutureTask2 to complete
FutureTask2 output is null
FutureTask2 output=pool-1-thread-2
Done

最终输出

FutureTask1 output=pool-1-thread-1
Waiting for FutureTask2 to complete
Waiting for FutureTask2 to complete
FutureTask2 output=pool-1-thread-2
Done

说明了一件事，即在超时期限内，如果未能获取线程返回值，futureTask2.get(500L, TimeUnit.MILLISECONDS) 将不对继续执行后面的代码，而是进行下一次的while操作了（并不是返回null），while的下一次循环，直到获取到了返回结果，String s才得以赋值，代码继续进行。

所以要慎用get(long timeout, TimeUnit unit)。

传统的理解是错误的：

get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

大神 海子 曾对这个问题有质疑，认为会抛出异常，并赋空值，见：

http://www.cnblogs.com/dolphin0520/p/3949310.html#3318489

我尝试修改代码

String s="aa";
        while (true)
        {
            try {
                if(futureTask1.isDone() && futureTask2.isDone()){
                    System.out.println("Done");
                    //shut down executor service
                    executor.shutdown();
                    return;
                }

                if(!futureTask1.isDone()){
                //阻塞futureTask1
                System.out.println("FutureTask1 output="+futureTask1.get());
                }

                System.out.println("Waiting for FutureTask2 to complete");
                s = futureTask2.get(500L, TimeUnit.MILLISECONDS); //阻塞500毫秒
                if(s !=null){
                    System.out.println("FutureTask2 output="+s);
                }
                else{
                    System.out.println("FutureTask2 output is null");
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }catch(Exception e){
                System.out.println("s is:"+s);
                //do nothing
            }
        }

s的预设值那里有改变：String s="aa";也没发现变为null，是没发生赋值。在异常中s也没有被赋空值。

所以在使用get(long timeout, TimeUnit unit)的时候，变量初始最好能给一个空值，这样就不会产生奇怪的结果，这也是合理的编程习惯。