В чем разница между ExecutorService.submit и ExecutorService.execute в этом коде на Java?

Как видно из JavaDoc, execute(Runnable) ничего не возвращает.

Однако submit(Callable<T>) возвращает объект Future, который позволяет вам позже программно отменить запущенный поток, а также получить T, который возвращается после завершения Callable. Дополнительные сведения см. в разделе JavaDoc будущего.

Future<?> future = executor.submit(longRunningJob);
...
//long running job is taking too long
future.cancel(true);

Более того, если future.get() == null и не выдает никаких исключений, то Runnable выполняется успешно

Разница в том, что execute просто запускает задачу без лишних слов, тогда как submit возвращает объект Future для управления задачей. Вы можете делать следующие вещи с объектом Future:

• Преждевременно отмените задачу методом cancel.
• Дождитесь завершения выполнения задачи с get.

Интерфейс Future более полезен, если вы отправляете Callable в пул. Возвращаемое значение метода call будет возвращено при вызове Future.get. Если вы не поддерживаете ссылку на Future, нет никакой разницы.

execute: Используйте его для огня и забудьте о звонках

submit: Используйте его, чтобы проверить результат вызова метода и принять соответствующие меры в отношении Future возражений, возвращенных вызовом.

Основное отличие: Exception обработка

submit() скрывает необработанные Exception в самом фреймворке.

execute() бросает необработанный Exception.

Решение для обработки исключений с помощью submit()

1. Оберните Callable or Runnable code in try{} catch{} block

   OR

2. Оставить future.get() call in try{} catch{} block

   OR

3. реализовать свой собственный метод ThreadPoolExecutor и переопределить метод afterExecute

Что касается тура, другие вопросы по

invokeAll< /а>:

invokeAny< /а>:

Выберите между отправкой ExecutorService и выполнением ExecutorService

Основное различие между методами submit() и execute() заключается в том, что ExecuterService.submit() может возвращать результат вычисления, потому что он имеет тип возвращаемого значения Future, но метод execute() не может ничего возвращать, поскольку его тип возвращаемого значения — void. Базовым интерфейсом в среде Executor Java 1.5 является интерфейс Executor, который определяет метод execute(Runnable task), основной целью которого является отделение задачи от ее выполнения.

Любая задача, отправленная в Executor, может быть выполнена тем же потоком, рабочим потоком из пула потоков или любым другим потоком.

С другой стороны, метод submit() определен в интерфейсе ExecutorService, который является подинтерфейсом Executor и добавляет функциональность завершения пула потоков, а также добавляет метод submit(), который может принимать вызываемую задачу и возвращать результат. вычислений.

Сходство между execute() и submit():

1. Оба метода submit() и execute() используются для отправки задачи в среду Executor для асинхронного выполнения.
2. И submit(), и execute() могут принимать задачу Runnable.
3. Вы можете получить доступ к submit() и execute() из интерфейса ExecutorService, потому что он также расширяет интерфейс Executor, который объявляет метод execute().

Помимо того факта, что метод submit() может возвращать выходные данные, а execute() не может, существуют и другие заметные различия между этими двумя ключевыми методами платформы Executor Java 5.

1. submit() может принимать как Runnable, так и Callable задачу, но execute() может принимать только Runnable задачу.
2. Метод submit() объявлен в интерфейсе ExecutorService, а метод execute() объявлен в интерфейсе Executor.
3. Тип возвращаемого значения метода submit() — объект Future, но тип возвращаемого значения метода execute() — void.

Submit — возвращает объект Future, который можно использовать для проверки результата отправленной задачи. Может использоваться для отмены или проверки isDone и т. д.

Выполнить - ничего не возвращает.

Если вы проверите исходный код, вы увидите, что submit является своего рода оболочкой для execute.

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

в основном выполняются оба вызова, если вам нужен будущий объект, вы должны вызвать метод submit() здесь из документа

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    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;
}

как вы можете видеть, у java действительно нет другого способа запустить поток, кроме вызова метода run(), IMO. так как я также обнаружил, что метод Callable.call() вызывается внутри метода run(). следовательно, если объект вызывается, он все равно вызовет метод run(), который, в свою очередь, вызовет метод call() из doc.

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     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);
    }
}

execute(Runnable command) — это реализованный метод из интерфейса Executor. Это означает, что просто выполните команду и ничего не получите.

ExecutorService имеет свои собственные методы запуска задач: submit, invokeAny и invokeAll, все из которых имеют экземпляры Callable в качестве основных целей. Хотя есть методы, использующие Runnable в качестве входных данных, на самом деле Runnable будет адаптировано к Callable в методе. почему Callable? Потому что мы можем получить результат Future<T> после отправки задачи.

Но когда вы преобразуете Runnable в Callable, результат, который вы получаете, это просто значение, которое вы передаете:

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

Итак, какой смысл в том, что мы передаем Runnable для отправки вместо того, чтобы просто получить результат, когда задача будет завершена? Потому что есть метод, который имеет только Runnable в качестве параметра без определенного результата.

Прочитайте javadoc Future:

Если вы хотите использовать Future ради отменяемости, но не предоставлять пригодный для использования результат, вы можете объявить типы в форме Future‹?› и вернуть null в результате базовой задачи.

Итак, если вы просто хотите выполнить задачу Runnable без какого-либо возвращаемого значения, вы можете использовать execute().

если вы хотите запустить задачу Callable, или

если вы хотите запустить задачу Runnable с указанным результатом в качестве символа завершения, или

если вы хотите запустить задачу и иметь возможность отменить ее,

вы должны использовать submit().