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