Java使用Future设置方法超时

1、使用线程包

java.util.concurrent.Future

2、Future代表一个异步计算的结果。

它提供了方法来检查是否计算已经完成，还是正在计算而处于等待状态，并且也提供了获取计算结果方法。当计算完成后，只能通过get方法来获取执行结果，必要的话该方法会阻塞。通过cancel方法可以取消计算。一旦计算已经完成，便无法取消。

主要方法：

cancel()：取消任务

get()：等待任务执行完成，并获取执行结果

get(long timeout, TimeUnit unit)：在指定的时间内会等待任务执行，超时则抛异常。

3、示例代码

 1 package Concurrent;
 2 
 3 import java.util.concurrent.*;
 4 
 5 /**
 6  * 测试方法的超时时间
 7  */
 8 public class FutureTest {
 9 
10     public static  void functionTimeoutTest2() throws  Exception{
11         ExecutorService executorService= Executors.newSingleThreadExecutor();
12         Future<String> future=executorService.submit(()->
13             {
14                 Thread.sleep(10000);
15                 return "success";
16             }
17         );
18 
19         try{
20             String result=future.get(5,TimeUnit.SECONDS);
21             //String result=future.get(50,TimeUnit.SECONDS);
22             System.out.println("result:"+result);
23         }
24         catch (TimeoutException e){
25             System.out.println("超时了!");
26         }
27     }
28 }

如果是java8以前的，可以使用下面这段代码：

 1 package Concurrent;
 2 
 3 import java.util.concurrent.*;
 4 
 5 /**
 6  * 测试方法的超时时间
 7  */
 8 public class FutureTest {
 9 
10     public static  void functionTimeoutTest() throws  Exception{
11         //java8建议使用lambda表达式来替代匿名内部类
12         Callable<String> task=new Callable<String>() {
13             @Override
14             public String call() throws Exception {
15                 Thread.sleep(10000);
16                 return "success";
17             }
18         };
19 
20         ExecutorService executorService= Executors.newSingleThreadExecutor();
21         Future<String> future=executorService.submit(task);
22         try{
23             String result=future.get(5,TimeUnit.SECONDS);
24             //String result=future.get(50,TimeUnit.SECONDS);
25             System.out.println("result:"+result);
26         }
27         catch (TimeoutException e){
28             System.out.println("超时了!");
29         }
30     }
31 }

4、Callable

Callable相当于Runnable,所以，这里实现的是一个线程，但是与Runnable不同的是，它是具有返回值的，这个返回值就是我们想要任务返回的结果，比如说，我们想要任务返回的是一个提示信息，那么，返回值可以是String,然后在我们要实现的call()方法中return一句提示信息，接着只要使用Future类的get()方法，就可以从里面得到提示信息了，只要任务完成。所以，由此我们可以知道，java SE5比起以前来，在并发这方面做了更多的工作，它完善了我们的并发线程机制，使我们可以更好的根据任务的完成情况来进行与其他任务的协作，比如说，我们可以通过Future的返回值来决定是否终止任务，或者开启另一个任务。任务的终止可以使用Future的方法future.cancel(boolean),其中boolean为true或false，来决定是否终止，至于开启另一个任务，可以重新开启另一个线程，但是这里就马上有个问题浮现出来，就是当Futrue的结果返回来时，该任务有没有结束呢？因为这时一定已经执行完该任务的call()方法。是的，该任务已经结束了，只是我们没有取出它的返回结果而已。

5、更进一步：使用FutureTask

FutureTask既实现Runnable又实现Callable，现在我们可以这样做：

 1 public static  void functionTimeoutTest3() throws  Exception{
 2         ExecutorService executorService= Executors.newSingleThreadExecutor();
 3         FutureTask<String> future=new FutureTask<>(()->
 4                 {
 5                     Thread.sleep(10000);
 6                     return "success";
 7                 }
 8         );
 9         executorService.execute(future);
10 
11         try{
12             String result=future.get(5,TimeUnit.SECONDS);
13             //String result=future.get(50,TimeUnit.SECONDS);
14             System.out.println("result:"+result);
15         }
16         catch (TimeoutException e){
17             System.out.println("超时了!");
18         }
19     }

这里就是FutureTask的一般用法，它最大的好处就是我们可以将任务交给执行器后执行其他操作，然后再从里面得到任务的结果。这里必须要注意，只有FutureTask这种既实现Runnable又实现Callable才能够通过executor()递交给ExecutorService,而Future不行，只能通过submit()，因为executor()要求的参数是一个实现了Runnable的类。