Реализация Темы через фьючерсы

Question

Интересно, если следующий будет правильная реализация

ExecutorService pool = Executors.newFixedThreadPool(MAX_NSH_THREADS); 
    Set<Future<Void>> futureRequest = new HashSet<Future<Void>>(); 

    for (String host : SomeCollection)) { 
     Callable<Void> callable = new FileExtractor(j); 
     Future<Void> future = pool.submit(callable); 
     futureRequest.add(future); 
    } 

    for (Future<Void> future : futureRequest) { 
     try { 
      future.get(); 
     } catch (Exception e) { 
      logger.error(e); 
     } 
    } 

    pool.shutdown(); 

Согласно Javadoc, future.get() ждет для выполнения, чтобы завершить для каждого потока, который (как я понимаю) означает, что для каждого из в будущем мы будем ждать получения результатов отдельно. Где польза от этого, или я не делаю это правильно?

Answer 1

Вы делаете это правильно.

Позволяет сказать, что SomeCollection содержит 100 единиц, и что FileExtractor занимает 5 секунд, и ваш пул потоков ExecutorService содержит 100 потоков.

Если вы начинаете вещи, как вы реализовали выше, ожидается, что код будет работать около 5 секунд, потому что FileExtractor, скорее всего, будет связан с I/O. (при условии максимальной эффективности ЦП).

Если вы не использовали Future, и все будет работать серийно, этот код будет работать около 500 секунд.

Ключ в том, что Future#get() ждет результата, чтобы быть заселена Thread начал, представив свои Callable в ExecutorService, а не ждать в методе ExecutorService#submit(Callable).

Answer 2

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

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