Блог

У меня возник вопрос во время изучения CompletableFuture . Методы get() / join() блокируют вызовы. Что, если я не вызываю ни один из них?

Этот код вызывает get() :

 // Case 1 - Use get()
CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1_000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Hello");
}).get();
System.out.println("World!");

Thread.sleep(5_000L); // Don't finish the main thread
 

Вывод:

 Hello
World!
 

Этот код get() не вызывает ни join() :

 // Case 2 - Don't use get()
CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1_000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Hello");
});
System.out.println("World!");

Thread.sleep(5_000L); // For don't finish main thread
 

Вывод:

 World!
Hello
 

Я не знаю, почему работает выполняемый блок case 2 .

Вся идея CompletableFuture заключается в том, что они должны быть немедленно запущены (хотя вы не можете достоверно сказать, в каком потоке они будут выполняться), и к тому времени, когда вы достигнете get или join , результат может быть уже готов, т. Е.: CompletableFuture возможно, уже завершен. Внутренне, как только определенный этап в конвейере будет готов, для этого конкретного CompletableFuture будет установлено значение completed . Например:

 String result = 
   CompletableFuture.supplyAsync(() -> "ab")
                    .thenApply(String::toUpperCase)
                    .thenApply(x -> x.substring(1))
                    .join();
 

это то же самое, что:

 CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "ab");
CompletableFuture<String> cf2 = cf1.thenApply(String::toUpperCase);
CompletableFuture<String> cf3 = cf2.thenApply(x -> x.substring(1));
String result = cf3.join();
 

К тому времени, когда вы дойдете до фактического вызова join , cf3 возможно, он уже завершится. get и join просто блокируйте, пока не будут выполнены все этапы, это не запускает вычисление; вычисление запланировано немедленно.

Незначительным дополнением является то, что вы можете завершить a CompletableFuture , не дожидаясь завершения выполнения конвейеров: например complete , completeExceptionally , obtrudeValue (этот устанавливает его, даже если он уже был завершен), obtrudeException или cancel . Вот интересный пример:

  public static void main(String[] args) {
    CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
        System.out.println("started work");
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(5));
        System.out.println("done work");
        return "a";
    });

    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
    cf.complete("b");
    System.out.println(cf.join());
}
 

Это приведет к:

 started work
b
 

Таким образом, даже если работа началась, конечное значение равно b , not a .

Я не знаю, почему Runnable работает блок case2.

Нет причин, по которым это НЕ сработало бы.

runAsync(...) Метод говорит о выполнении задачи асинхронно. Предполагая, что приложение не завершается преждевременно, задача в конечном итоге будет выполнена, независимо от того, ждете вы ее выполнения или нет.

CompletableFuture Предоставляет различные способы ожидания завершения задачи. Но в вашем примере вы не используете его для этой цели. Вместо Thread.sleep(...) этого вызов вашего основного метода имеет тот же эффект; т. Е. Он ожидает достаточно долго, чтобы задача (вероятно) завершилась. Так "Hello" выводится раньше "World" .

Просто чтобы повторить, get() вызов не вызывает выполнение задачи. Скорее он ждет, пока это произойдет.

Использование sleep для ожидания события (например, завершения задачи) — плохая идея:

1. Sleep не сообщает, произошло ли событие!
2. Обычно вы не знаете точно, сколько времени потребуется для события, вы не знаете, как долго спать.
3. Если вы спите слишком долго, у вас «мертвое время» (см. Ниже).
4. Если вы спите недостаточно долго, событие, возможно, еще не произошло. Так что вам нужно протестировать и поспать еще раз, и еще, и еще…

Даже в этом примере теоретически возможно ¹ для завершения sleep in main перед sleep in задачей.

По сути, цель CompletableFuture состоит в том, чтобы обеспечить эффективный способ ожидания завершения задачи и выдачи результата. Вы должны использовать его…

Для иллюстрации. Ваше приложение ожидает (и тратит впустую) ~ 4 секунды между выводом "Hello" и "World!" . Если бы вы использовали CompletableFuture так, как оно предназначено для использования, у вас не было бы этих 4 секунд «мертвого времени».

^{1 — Например, какой-то внешний агент может выборочно «приостановить» поток, выполняющий задачу. Это может быть сделано путем установки точки останова…}

Второй случай «работает«, потому что вы спите в основном потоке достаточно долго (5 секунд). Работа заключается в кавычках, потому что на самом деле она не работает, просто завершается. Я предполагаю, что здесь код должен выводиться Hello World! , чтобы считаться «работающим должным образом«.

Попробуйте тот же код с этим временем ожидания в конце основного потока в обоих случаях:

Thread.sleep(100);

1. Первый будет вести себя точно так же, поскольку операция get блокирует основной поток. Фактически, в первом случае вам даже не нужно время последнего ожидания.

Вывод: Hello World!

2. Второй случай не будет выведен Hello , так как никто не сказал основному потоку: «Эй, подождите, пока это закончится«. Это то, что get() делает: блокирует вызывающего, чтобы дождаться завершения задачи. Без этого и установки низкого времени ожидания в конце вызывается runnable, но не может завершить свою работу до остановки основного потока.

Вывод: World!

Это также причина, по которой в первом случае Hello World! (сначала вывод runnable, а затем основной — это означает, что основной поток был заблокирован до get() возвращения) записывается, в то время как во втором видны тонкие признаки дислексии: World Hello!

Но это не дислексия, он просто выполняет то, что ему говорят. Во втором случае это происходит:

1. Вызывается runnable.

2. Основной поток продолжает свой процесс, печатая («Мир!)

3. Sleep время установлено: 1 секунда на исполняемом / 5 секунд на основном. (режим сна runnable также может быть выполнен во время 2-го шага, но я поместил его здесь, чтобы прояснить поведение)

4. Выполняемая задача печатается («Привет») через 1 секунду, и завершаемое будущее завершено.

Прошло 5,5 секунд, основной поток останавливается.

Таким образом, ваш runnable мог печатать Hello , потому что он смог выполнить команду в промежутке между этими 5 секундами ожидания.

 World! . . . . . .(1)Hello. . . . . . . . . . .(5)[END]
 

Если вы уменьшите тайм-аут последних 5 секунд, например, до 0,5 секунды, вы получите

 World!. . (0.5)[END]