并发编程系列之Callable和Runnable的不同？

public  static void main(String[] args) {
	Thread t  = new Thread(new RunnableTask ());
	t.start();
}
static class RunnableTask implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

Runnable runnable = new Runnable() {
    /**
     * run方法是不允许在声明throws Exception的，
     * 且run方法内无法 throw 出 checked Exception，
     * 除非使用try catch进行处理
     */
    @Override
    public void run() {
        try {
            throw new IOException();
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
};
}

public static void callableExecutorService() throws InterruptedException, ExecutionException {
     ExecutorService service = new ThreadPoolExecutor(10, 10,
             60L, TimeUnit.SECONDS,
             new ArrayBlockingQueue(10));

     Future<Integer> future = service.submit(new CallableTask());
     Thread.sleep(3000);
     System.out.println("future is done?" + future.isDone());
     if (future.isDone()) {
         System.out.println("callableTask返回参数:"+future.get());
     }
     service.shutdown();
}

static class CallableTask implements Callable<Integer> {
    @Override
    public Integer call() {
        return ThreadLocalRandom.current().ints(0, (99 + 1)).limit(1).findFirst().getAsInt();
    }
}

public static void callableFutureTask() throws InterruptedException, ExecutionException {
    CallableTask task = new CallableTask();
    FutureTask futureTask = new FutureTask(task);
    Thread t = new Thread(futureTask);
    t.start();
    Thread.sleep(1000L);
    System.out.println("task result:" + futureTask.get());
}
static class CallableTask implements Callable<Integer> {
    @Override
    public Integer call() {
        return ThreadLocalRandom.current().ints(0, (99 + 1)).limit(1).findFirst().getAsInt();
    }
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}