JAVA并发编程之Callable、Futrue接口简单应用篇

Callable 和 Runnable 的使用方法大同小异， 区别在于：
1.Callable 使用 call（） 方法， Runnable 使用 run() 方法
2.call() 可以返回值， 而 run()方法不能返回。
3.call() 可以抛出受检查的异常，比如ClassNotFoundException， 而run()不能抛出受检查的异常。

Future接口
Future是一个接口，代表了一个异步计算的结果。接口中的方法用来检查计算是否完成、等待完成和得到计算的结果，方法如下：
1、V get():返回Callable接口中call()的返回值。调用该方法将导致程序堵塞，必须等到子线程结束才会得到返回值
2、V get(long timeout, TimeUnit unit);指定时间内返回值，若在指定时间内没有返回则返回NULL
3、boolean cancel(boolean mayInterruptIfRunning):试图取消Future里关联的Callable任务
4、boolean isCancelled():如果在Callable任务正常完成前被取消，则返回true
5、boolean isDone():如果在Callable任务已完成，则返回true

FutureTask类
FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口，所以说FutureTask是一个提供异步计算的结果的任务。
FutureTask可以用来包装Callable或者Runnbale对象。因为FutureTask实现了Runnable接口，所以FutureTask也可以被提交给Executor

Callable示例如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

 public static void main(String[] args) {
    	
       // CountSum countSum = new CountSum(); 创建一个Callable对象，此CountSum需实现Callable接口
        
        Callable<Integer> countSum = new Callable<Integer>() {

			@Override
			public Integer call() throws Exception {
				System.out.println("子线程1开始执行...");
	            int sum = 0;
	            for (int i = 0; i < 10000; i++) {
	                sum += i;
	            }
	            Thread.sleep(2000);
	            System.out.println("线程："+Thread.currentThread().getName()+"执行结果="+sum);
	            return sum;
			}
        	
		};
		
		 Callable<Integer> countSum1 = new Callable<Integer>() {

				@Override
				public Integer call() throws Exception {
					   System.out.println("子线程2开始执行...");
			            int sum = 0;
			            for (int i = 0; i < 10000; i++) {
			                sum += i;
			            }
			            Thread.sleep(3000);
			            System.out.println("线程："+Thread.currentThread().getName()+"执行结果="+sum);
			            return sum;
				}
	        	
			};
        
        FutureTask<Integer> futureTask = new FutureTask<>(countSum);// 创建FutureTask对象
        FutureTask<Integer> futureTask1 = new FutureTask<>(countSum1);// 创建FutureTask对象

        ExecutorService executorService = Executors.newCachedThreadPool();// 创建线程池
        executorService.submit(futureTask);
        executorService.submit(futureTask1);
       long beginTime = System.currentTimeMillis();
        System.out.println("主线程开始时间："+beginTime);
        try {
        	//int sum = futureTask.get();
        	//int sum1 = futureTask1.get();
            boolean done = futureTask.isDone();
            boolean done1 = futureTask1.isDone();
           // System.out.println("主线程获得求和结果：" + sum);
            if(done==true && done1 == true) {
            	 long endTime = System.currentTimeMillis();
                 System.out.println("主线程结束时间："+endTime);
                 long   time = endTime - beginTime;
                 System.out.println("总耗时："+time+"ms");
            }
           
        } catch (Exception e) {
            e.printStackTrace();
            futureTask.cancel(true);
        } finally {
            executorService.shutdown();
        }
    }

运行结果：
子线程1开始执行…
子线程2开始执行…
主线程开始时间：1560045843456
线程：pool-2-thread-1执行结果=49995000
线程：pool-2-thread-2执行结果=49995000
主线程结束时间：1560045846456
总耗时：3000ms

主线程创建子线程并将任务交给子线程异步处理，主线程处理时间取决于耗时最长的子线程，大大提高了代码的运行效率。
大家在面对业务量复杂的场景下记得使用多线程Callable接口。

以下是我根据Callable接口特性的一点思考(未测)：
既然callable是有返回值的，那么我们在写spring MVC时就可以用Callable返回。
请求进入控制器后开启一个主线程，使用Callable后将任务交给子线程异步处理，这样是不是就在代码层次上间接地提高了程序的吞吐量和性能呢？
建议大家可以自己去实现并测压一下！

其实除了上面这种方式实现异步编程的话，还有一种更为优雅的方式实现，可参考我的另一篇博客（使用@Async注解处理异步调用）：
https://blog.csdn.net/qq_35290857/article/details/94832737