Java-多线程：Callable接口和Runnable接口之间的区别

@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;
}

@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();
}

/**
 * @author Fisherman
 */
public class TheWayOfUsingRunnable {
    public static void main(String[] args) {
        //1)lambda表达式形式传递给线程构造器
        Runnable runnable1 = () -> {
            System.out.println("我是使用lambda表达式实现的Runnable对象实现 version1");
        };

        Thread thread1 = new Thread(runnable1);
        thread1.start();

        Thread thread1_1 = new Thread(() -> {
            System.out.println("我是使用lambda表达式实现的Runnable对象实现 version2");
        });
        thread1_1.start();

        //2）匿名内部类的方式实现Runnable对象的传入Thread构造器

        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("我是使用匿名内部类的方式实现的Runnable对象实现");
                    }
                }
        ).start();

        //3)使用实现了Runnable接口的对象实例传入Thread构造器
        RunnableTask runnableTask = new RunnableTask();
        new Thread(runnableTask).start();

        //4）Runnable类以及其子类作为线程任务提交给线程池，通过线程池维护的工作者线程来执行。
        Runnable runnable2 = () -> {
            System.out.println("我是使用lambda表达式实现的Runnable对象实现 不同的是：用于线程池的实现");
        };
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.execute(runnable2);
        executor.shutdown();
    }

    /**RunnableTask
     * Runnable接口子类的实现类：RunnableTask
     */
    private static class RunnableTask implements Runnable{
        @Override
        public void run() {
            System.out.println("实现了Runnable接口的子类的对象实现");
        }

        //额外写一个方法：get
        public String get(){
            return "I am Fisherman.";
        }
    }

}

public class TheWayOfUsingCallable {
    public static void main(String[] args) {
        //callable对象实例可以作为线程池的submit()方法入口参数
        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();
        }
    }
}
class IntegerCallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        Thread.sleep(1000);
        for (int i = 0; i < 101; i++) {
            sum += i;
        }
        return sum;
    }
}