浅谈线程池之submit方法和execute方法

1.首先说一下ExecutorService和Executor有什么区别，ExecutorService 是一个接口，它继承自Executor接口，所以ExecutorService使用Executor里面的方法

2.execute方法是Executor接口里面的方法，不是ExecutorService接口里的方法，如果如果使用execute方法的话，其实是调用其父类的方法。

Executor接口只有一个execute方法，并且是没有返回值的，并且只接受Runnable，不接受Callable

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

ExecutorService接口是没有execute方法的，所以平时我们创建线程池使用的execute方法其实是其父类的方法，ExecutorService里重载里三个submit方法

public interface ExecutorService extends Executor {

    void shutdown();

  
    List<Runnable> shutdownNow();

   
    boolean isShutdown();

    
    boolean isTerminated();

   
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

   
    <T> Future<T> submit(Callable<T> task);

   
    <T> Future<T> submit(Runnable task, T result);

   
    Future<?> submit(Runnable task);

   
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

   
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;


    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

3.submit方法:首先我们知道Callable是有返回值的，Runnable是没有返回值的，但是我们一般使用线程池都会想要知道这个线程的执行情况，Callbale使用线程池结合Future可以获取线程运行的情况，其实线程池使用Runnable也是可以有返回值的

submit重载里三个方法，

我们先来看第一个submit()方法

 <T> Future<T> submit(Callable<T> task);

返回值是一个泛型，形参是实现了Callable的类，我们来看一下 他具体的方法，具体的方法在AbstractExecutorService类里面，AbstractExecutorService类是ExecutorService的实现类。

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

第八行，其实submit方法到归根到底还是走的execute方法。

我们来看下第二个submit()方法

/**
     * Submits a Runnable task for execution and returns a Future
     * representing that task. The Future's {@code get} method will
     * return {@code null} upon <em>successful</em> completion.
     *
     * @param task the task to submit
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    Future<?> submit(Runnable task);

这个submit()方法的形参是实现里Runnable的类，但是他是有返回值的，返回值是Future

下面是他的实现类

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

第七行的方法，其实还是把Runnable转化成Callable了

/**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Runnable}, and arrange that {@code get} will return the
     * given result on successful completion.
     *
     * @param runnable the runnable task
     * @param result the result to return on successful completion. If
     * you don't need a particular result, consider using
     * constructions of the form:
     * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
     * @throws NullPointerException if the runnable is null
     */
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

如果传递进来的方法是Runnable的话，这里会把Runnable转化成Callable，用的是Executors里面的方法

 /**
     * A callable that runs given task and returns given result
     */
    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

好，回到submit方法，第三行依然走的是executor方法。

第三种submit()方法

  /**
     * Submits a Runnable task for execution and returns a Future
     * representing that task. The Future's {@code get} method will
     * return the given result upon successful completion.
     *
     * @param task the task to submit
     * @param result the result to return
     * @param <T> the type of the result
     * @return a Future representing pending completion of the task
     * @throws RejectedExecutionException if the task cannot be
     *         scheduled for execution
     * @throws NullPointerException if the task is null
     */
    <T> Future<T> submit(Runnable task, T result);

  /**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     */
    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;
    }

这种submit()使用泛型的result把返回值返回回去，这种底层还是把Runnable方法转换成Callable

   public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

所以不管是Runnable还是Callable，只要使用线程池的submit()方法，都可以实现有返回值的效果。