java学习----多线程Callable接口

java–Callable接口

1.基本介绍

简单的介绍一下会用到的两个新的接口，用Callable的时候，一般我们是把任务交给线程池去执行，而不是直接交给线程。

1.1Callbale接口

public interface Callable<V>{
	public V call() throws Exception;
	
}

Callable可调用对象
JDK5假如，与Runnable接口类似，实现后代表一个线程任务。
与Runnable不同之处在于具有泛型返回值，可以声明异常。

1.2Future接口介绍

用于异步接收ExecutorService.submit()所返回的状态结果，当中包含了call()的返回值。

常用方法，V get()以阻塞的形式等待Future中的异步处理结果（call()的返回值）

2.简单尝试

实现返回0到100相加的值并打印出来。
下面是示例代码
首先是MyCallable类，继承Callbale接口，重写call()函数。实现的是0-100相加求和的功能。

public class MyCallbale implements Callable<Integer> {
    
    @Override
    public Integer call() throws Exception {

        System.out.println("开始执行");
        int sum = 0;
        for(int i = 0; i <= 100; i++){
            //这里加这个等待的时间是为了，更明显的看出get的阻塞效果，除此之外没有别的含义。
            Thread.sleep(50);
            sum += i;
        }
        System.out.println("执行结束了");
        return sum;
    }
}

之后是主函数，使用了线程池，以及利用Future接口的get()方法来获取返回值（Future接口概念：异步接收，ExecutorService .submit()的返回结果，其提供的get()方法异步等待call()的返回值），这个案例可以清楚地看到，get()的阻塞线程的效果。
主函数代码如下所示。

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义任务
        MyCallbale task = new MyCallbale();

        //定义线程池
        ExecutorService es = Executors.newSingleThreadExecutor();

        //提交任务，这里future会异步接收es正在执行的task的返回值
        Future<Integer> future = es.submit(task);

        //关闭线程池
        es.shutdown();

        //获取返回值,这里的get是阻塞式的等待future的返回值的
        Integer sum = future.get();

        System.out.println(sum);
    }

3. 小案例，使用两个线程并发的计算1-50、51-100的和，在进行汇总相加。

要思考的点是，如何获取call的返回值？
步骤：

1. 将两个任务分别创建出来，一个计算1-50的和，另一个计算51-100的和
2. 创建线程池，因为只有两个任务，所以创建固定线程数量的线程池
3. 将两个任务提交到线程池，并利用Future接口的get方法接收返回的结果

import java.util.concurrent.*;

public class TestFuture {

    public static void main(String[] args) throws Exception{

        //匿名内部类
        Callable<Integer> thread1 = new Callable<Integer>(){
            @Override
            public Integer call() throws Exception{

                System.out.println(Thread.currentThread().getName() + "正在执行1-50的和");
                int sum = 0;
                for(int i = 1; i < 50; i++ ){
                    sum += i;
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
                return sum;
            }
        };

        //匿名内部类
        Callable<Integer> thread2 = new Callable<Integer>(){
            @Override
            public Integer call() throws Exception{

                System.out.println(Thread.currentThread().getName() + "正在执行50-100的和");
                int sum = 0;
                for(int i = 50; i < 101; i++ ){
                    sum += i;
                }
                System.out.println(Thread.currentThread().getName() + "执行完成");
                return sum;
            }
        };

        ExecutorService es =  Executors.newFixedThreadPool(2);
        Future<Integer> sum1 = es.submit(thread1);
        Future<Integer> sum2 = es.submit(thread2);

        Integer total = sum1.get() + sum2.get();

        System.out.println(total);
    }
}