execute和submit的区别

execute方法位于接口Executor中。

    void execute(Runnable command);

submit方法位于AbstractExecutorService中。

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

根据源码可以看到execute仅可以接受Runnable类型，而submit重载了三个方法，参数可以是Runnable类型的接口、Runnable类型接口加泛型result以及Callable类型的接口。

从上面的方法也可以看出实际上如果用Runnable类型的接口也是可以有返回值的。

传递Runnable类型接口加result会被进一步封装，在Executors这个类里面有个内部类RunnableAdapter实现了Callable接口。

    private static final class RunnableAdapter<T> implements Callable<T> {
        private final Runnable task;
        private final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
        public String toString() {
            return super.toString() + "[Wrapped task = " + task + "]";
        }
    }

看submit方法可以看出，submit最终也是在调用execute方法，无论是Runnable还是Callable类型接口，都会被封装成FutureTask继续执行。

总结：如果使用submit方法提交，会进一步封装成FutureTask，执行execute方法，在FutureTask里面重写的run方法里面调用Callable接口的call方法。

    public void run() {
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }