Callable

Callable

　　Thread和Rnnable接口都不允许声明检查类型异常，也不能定义返回值。
　　public void run()方法契约意味着必须捕获并处理检查型异常。即使小心地保存了异常信息以便以后检查，但也不能保证这个类的所有使用者都读取异常信息。
　　Callable与Runnable的区别在于：
- Callable规定的方法是call()，而Runnable是run();
- Callable的任务执行可返回值，而Runnable的任务不能有返回值；
- call()方法可抛出异常，而run()不能抛出异常；
- 运行Callable任务可拿到Futrue对象.

　　Future对象是Callable任务返回的结果，Callable产生结果，future拿到结果。
　　Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果。也可以设置任务执行的超时时间，这个设置超时的方法就是实现Java程序执行超时的关键。所以，如果需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest1 {
    public static void main(String[] args) {
        //与线程池配合使用
        CallableDemo cd = new CallableDemo();
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> result = executor.submit(cd);
        int i = 0;
        try {
            i = result.get();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(i);
    }
}

class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        return new Random().nextInt(1000);
    }

}

Future

ԈԈ在Future接口中声明了5个方法：
- isCancelled方法表示任务是否被取消，如果正常被取消，则返回true；
- isDone方法表示任务已经完成，若完成，返回true；
- get方法获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
- get(long timeout, TimeUnit unit)用来获取执行结构，如果在指定时间内，还没获取到结果，就直接返回null。

　Ԉ也就是说Future提供了三个功能：
1. 判断任务是否完成；
2. 中断任务；
3. 获取执行结果。

　　Future只是一个接口，所以无法直接创建对象，因此有了实现类FutureTask。

import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTaskRunnable {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Future<String> result = executor.submit(new Runnable() {
            public void run() {
                // TODO Auto-generated method stub
                int i = new Random().nextInt(100);
                System.out.println(i);
            }

        },"任务完成");

        FutureTask<String> future2 = new FutureTask<String>(new Runnable() {
            public void run() {
                // TODO Auto-generated method stub
                int i = new Random().nextInt(100);
                System.out.println(i);
            }

        }, "任务完成");


        //FutureTask实现了Runnable接口，所以可以直接调用execute()方法执行。
        //executor.execute(future2);
        executor.submit(future2);
        String str = "str";
        try {
            str = future2.get();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(str);
    }
}