Runnable和Callable接口的区别是什么？多线程返回值与异常处理详解

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

public interface Runnable {
    public abstract void run();
}

package com.callable.runnable;

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

/**
 * Created on 2016/5/18.
 */
public class CallableImpl implements Callable<String> {

    public CallableImpl(String acceptStr) {
        this.acceptStr = acceptStr;
    }

    private String acceptStr;

    @Override
    public String call() throws Exception {
        // 任务阻塞 1 秒
        Thread.sleep(1000);
        return this.acceptStr + " append some chars and return it!";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> callable = new CallableImpl("my callable test!");
        FutureTask<String> task = new FutureTask<>(callable);
        long beginTime = System.currentTimeMillis();
        // 创建线程
        new Thread(task).start();
        // 调用get()阻塞主线程，反之，线程不会阻塞
        String result = task.get();
        long endTime = System.currentTimeMillis();
        System.out.println("hello : " + result);
        System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!");
    }
}

System.out.println("start...");
        long begin = System.currentTimeMillis();
        // 创建一个线程池
        int taskSize = 5;
        ExecutorService pool = Executors.newFixedThreadPool(taskSize);
        ExecutorCompletionService<String> completionService = new ExecutorCompletionService<String>(pool);
        try {
            for (int i = 1; i <= taskSize; i++) {
                MyCallable callable = new MyCallable(new Integer(i));
                completionService.submit(callable);
            }
            pool.shutdown();
            for (int i = 1; i <= taskSize; i++) {
                System.out.println(completionService.take().get());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 关闭线程池
        long end = System.currentTimeMillis();
        System.out.println("end..excute time：" + (end - begin) + "ms");
        return;

System.out.println("start...");
                long begin = System.currentTimeMillis();
                ExecutorService pool = null;
                try {
                    int taskSize = 5;
                    // 创建一个线程池
                    pool = Executors.newFixedThreadPool(taskSize);
                    // 创建多个返回值的任务
                    List<Future> list = Lists.newArrayList();
                    for (int i = 1; i <= taskSize; i++) {
                        MyCallable callable = new MyCallable(new Integer(i));
                        Future<String> future = pool.submit(callable);
                        list.add(future);
                        System.out.println("已添加" + i);
                    }
                    for (int i = 0; i < list.size(); i++) {
                        System.out.println(list.get(i).get().toString());
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 关闭线程池
                pool.shutdown();
                long end = System.currentTimeMillis();
                System.out.println("end..excute time：" + (end - begin) / 1000 + "s");
                return;