Runnable和Callable的区别

创建线程的四种方式

Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

ava多线程有两个重要的接口，Runnable和Callable，分别提供一个run方法和call方法，二者是有较大差异的。

1）Runnable提供run方法，无法通过throws抛出异常，所有CheckedException必须在run方法内部处理。Callable提供call方法，直接抛出Exception异常。

2）Runnable的run方法无返回值，Callable的call方法提供返回值用来表示任务运行的结果

3）Runnable可以作为Thread构造器的参数，通过开启新的线程来执行，也可以通过线程池来执行。而Callable只能通过线程池执行。

一、Runnable使用场景

1）作为Thread的构造参数开启新的线程，以下是常用的通过匿名内部类的方式创建线程。

    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("I am a runnable task");
        }
    });
    thread.start();

2）由于Java只提供单继承，故创建线程时一般通过实现Runnable接口，来实现run方法的具体逻辑。然后实例化，作为Thread的构造参数开启线程。

class RunnableTask implements Runnable {
    @Override
    public void run() {
        System.out.println("I am a runnable task");
    }
}

main方法：

    RunnableTask runnableTask = new RunnableTask();
    Thread thread1 = new Thread(runnableTask);
    thread1.start();

其实1）和2）的本质是一样的。

3）作为线程任务提交给线程池，通过线程池维护的工作者线程来执行。

    ExecutorService executor = Executors.newCachedThreadPool();
    RunnableTask runnableTask = new RunnableTask();
    executor.execute(runnableTask);
    executor.shutdown();

二、Callable的使用场景

因为Callable的call方法提供返回值，所以当你需要知道任务执行的结果时，Callable是个不错的选择。Callable的实现很简单。

如下两个Callable任务分别返回false和0到520整数之和。

class BooleanCallableTask implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        return false;
    }
}
class IntegerCallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 520; i++) {
            sum += i;
        }
        return sum;
    }
}

Callable任务通过线程池的submit方法提交。且submit方法返回Future对象，通过Future的get方法可以获得具体的计算结果。而且get是个阻塞的方法，如果任务未执行完，则一直等待。

    ExecutorService executor = Executors.newCachedThreadPool();
    IntegerCallableTask integerCallableTask = new IntegerCallableTask();
    Future<Integer> future = executor.submit(integerCallableTask);
    executor.shutdown();
    try {
        System.out.println(future.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

三、关于Future和FutureTask

对于Calleble来说，Future和FutureTask均可以用来获取任务执行结果，不过Future是个接口，FutureTask是Future的具体实现，而且FutureTask还间接实现了Runnable接口，也就是说FutureTask可以作为Runnable任务提交给线程池。

以下是个具体的实例演示FutureTask各种的使用方式。

   static class Task implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程在进行计算");
            Thread.sleep(1000);
            int sum = 0;
            for (int i = 0; i < 10000; i++)
                sum += i;
            return sum;
        }
    }

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

    ExecutorService executor = Executors.newCachedThreadPool();
    //使用FutureTask
    Callable<Integer> task = new Task();
    FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
    executor.submit(futureTask);

    //使用Future
	//Callable<Integer> call = new Task();
	//Future<Integer> future = executor.submit(call);

    executor.shutdown();
    System.out.println("主线程在执行任务");
    Thread.sleep(2000);
    try {
        System.out.println("task运行结果" + futureTask.get()); //future.get()
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.println("所有任务执行完毕");
}

这个例子中使用Future和FutureTask都是一样的，都能获得相同的计算结果。