FixedThreadPool против CachedThreadPool: меньшее из двух зол

У меня есть программа, которая порождает потоки (~ 5-150), которые выполняют кучу задач. Первоначально я использовал a, FixedThreadPoolпотому что этот аналогичный вопрос предполагал, что они лучше подходят для более длительных задач, и с моими очень ограниченными знаниями о многопоточности я считал средний срок службы потоков (несколько минут) « долгоживущим ».

Однако недавно я добавил возможность создавать дополнительные потоки, и при этом я превысил установленный мной предел потоков. В этом случае было бы лучше угадать и увеличить количество потоков, которое я могу разрешить, или переключиться на a, CachedThreadPoolчтобы у меня не было потраченных впустую потоков?

Предварительно попробовав их обоих, похоже , нет никакой разницы, поэтому я склоняюсь к тому, чтобы CachedThreadPoolпросто избежать потерь. Однако означает ли срок жизни потоков, что я должен вместо этого выбрать FixedThreadPoolи просто обработать неиспользуемые потоки? Из-за этого вопроса кажется, что лишние потоки не потрачены впустую, но я был бы признателен за разъяснения.

CachedThreadPool - это именно то, что вы должны использовать в своей ситуации, поскольку нет никаких отрицательных последствий для использования его для длительно работающих потоков. Комментарий в java-документе о том, что CachedThreadPools подходят для коротких задач, просто предполагает, что они особенно подходят для таких случаев, а не о том, что они не могут или не должны использоваться для задач, связанных с длительными задачами.

Для дальнейшего уточнения, Executors.newCachedThreadPool и Executors.newFixedThreadPool поддерживаются одной и той же реализацией пула потоков (по крайней мере, в открытом JDK) только с разными параметрами. Отличия заключаются только в минимуме и максимуме потока, времени уничтожения потока и типе очереди.

public static ExecutorService newFixedThreadPool(int nThreads) {
     return new ThreadPoolExecutor(nThreads, nThreads,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>());
 }

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                 60L, TimeUnit.SECONDS,
                                 new SynchronousQueue<Runnable>());
}

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

Однако это означает, что единственная проблема, с которой вы можете столкнуться с CachedThreadPool, связана с ограничением количества потоков, выполняемых одновременно. CachedThreadPool не ограничит их за вас, поэтому вам может потребоваться написать собственный код, чтобы гарантировать, что вы не запускаете слишком много потоков. Это действительно зависит от дизайна вашего приложения и того, как задачи передаются в службу исполнителя.

Оба FixedThreadPoolи CachedThreadPool- зло в сильно загруженных приложениях.

CachedThreadPool опаснее чем FixedThreadPool

Если ваше приложение сильно загружено и требует низкой задержки, лучше избавиться от обоих вариантов из-за следующих недостатков

1. Неограниченный характер очереди задач: это может привести к нехватке памяти или высокой задержке
2. Длительно работающие потоки приведут CachedThreadPoolк выходу из-под контроля при создании потока

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

1. Установите очередь задач как ограниченную очередь, чтобы лучше контролировать
2. Правильный RejectionHandler - ваш собственный RejectionHandler или обработчики по умолчанию, предоставляемые JDK
3. Если вам нужно что-то сделать до / после завершения задачи, переопределите beforeExecute(Thread, Runnable)иafterExecute(Runnable, Throwable)
4. Переопределить ThreadFactory , если требуется настройка потока
5. Управляйте размером пула потоков динамически во время выполнения (связанный вопрос SE: динамический пул потоков )

Итак, у меня есть программа, которая порождает потоки (~ 5–150), которые выполняют кучу задач.

Вы уверены, что понимаете, как потоки на самом деле обрабатываются вашей ОС и выбранным оборудованием? Как Java сопоставляет потоки с потоками ОС, как это сопоставляет потоки с потоками процессора и т. Д.? Я спрашиваю, потому что создание 150 потоков внутри ОДНОЙ JRE имеет смысл только в том случае, если у вас есть массивные ядра / потоки ЦП под ними, что, скорее всего, не так. В зависимости от используемой ОС и ОЗУ создание более n потоков может даже привести к завершению работы JRE из-за ошибок OOM. Таким образом, вы должны действительно различать потоки и работу, которую они должны выполнять, сколько работы вы даже можете обработать и т. Д.

И в этом проблема с CachedThreadPool: нет смысла ставить в очередь длительную работу в потоках, которые на самом деле не могут выполняться, потому что у вас есть только 2 ядра ЦП, способные обрабатывать эти потоки. Если у вас останется 150 запланированных потоков, вы можете создать много ненужных накладных расходов для планировщиков, используемых в Java и ОС для их одновременной обработки. Это просто невозможно, если у вас всего 2 ядра ЦП, если только ваши потоки не ждут ввода-вывода или чего-то подобного все время. Но даже в этом случае множество потоков создаст много операций ввода-вывода ...

И эта проблема не возникает с FixedThreadPool, созданным, например, с помощью 2 + n потоков, где n, конечно, разумно низкое, потому что с этим оборудованием и ресурсами ОС используются гораздо меньше накладных расходов для управления потоками, которые все равно не могут выполняться.