Путь производительности Java против блокировки

Question

Я рассматриваю два подхода для отправки сообщений определенного типа по сети.

1) Существует LoadBalancer с внутренним кешем, который имеет ссылку на каналы. Каждый канал имеет внутренний поток (вызываемый), который имеет реализацию для отправки сообщений и открытого интерфейса, на котором он принимает запросы sendMessage.

Канал предлагает метод LoadBalancer, на котором он может выполнять неблокирующую погоду запроса, он доступен для отправки другого сообщения.

Подводя итог: существует одна нить для LoadBalancer, которая непрерывно объединяет список каналов с чем-то вдоль линий isChannelReady() и отправляет другое сообщение, когда канал готов.

public class SomeLoadBalancingStrategy implements LoadBalancer { 
private List<Channel> channels = ChannelFactory.getChannels(//parameters here) 

// read from some queue 
while(there are messages) { 

foreach (channel) { 

// non blocking query 
if(channel.isReady()) { 

     channel.sendMessage(message) 
    } 
    } 
} 

2) Каждый объект канала представляет собой исполняемую нить, которая обертывает внутреннюю вызываемую ответственность за отправку сообщений. Каналы блокируются в некоторой параллельной очереди, ожидающей появления новых сообщений. Когда сообщение добавляется в очередь, канал runnable выбирает его и переходит к вызываемому. Этот runnable заблокирован в ожидании результата. Как только результат вызываемого доступен, обертка потока будет отображать следующее сообщение из очереди, возможно, через интерфейс LoadBalancer.

Итак, суммируем: есть два потока на канал, один из которых является вызываемым и отправляет сообщение, а второй ждет этого результата, чтобы он мог получить следующий запрос. В этом случае нет отдельных сообщений диспетчеризации потока LoadBalancer для каналов.

Некоторые примечания:

• каналы используют синхронную связь с конечной точкой

• Пожалуйста, обратите внимание мое объяснение решений только в качестве шаблона для базовых идей, которые я хотел бы обсудить

• Там будет небольшое количество каналов, 5 не более

Будет ли второй подход всегда лучше работать? Существуют ли условия, при которых первый вариант был бы лучше? Аппаратное обеспечение, ОС, что-нибудь? Если каналы были асинхронными, изменилось бы это?

Answer 1

Решение номер один, похоже, имеет постоянный опрос в балансировщике нагрузки, запрашивающий каждый канал, готов ли он.

Это позволит добавить ненужное потребление ЦП. Я бы изменил 1), чтобы избежать этого, сохранив очередь блокировки «готовых» каналов. Балансировщик нагрузки вытащил готовый канал из очереди, и каналы добавили бы себя в очередь, когда они будут готовы к другому запросу.

В 2) Не видите, почему вам нужны два потока на канал, если это не навязывается внедрением операционного распределителя (API-интерфейса Callable?).

IMO оба варианта кажутся вполне эквивалентными по производительности, я не понимаю, почему один мог бы сделать намного лучше, чем другой; что 1) может гарантировать, что все каналы одинаково используются в циклическом фазировании, тогда как в 2), если есть низкий поток сообщений, существует вероятность того, что тот же канал всегда выполняет работу в зависимости от того, как виртуальная машина управляет коллекцией потоков Java, ожидающих появления нового элемента в очереди сообщений запроса.

Answer 2

Будет ли второй подход всегда лучше работать с мудрым?

Невозможно сказать. Лучший вариант - проверить оба подхода. Обычно самое простое решение лучше всего, и добавление очереди перед очередью не всегда полезно (поток TCP - это очередь байтов)

Есть ли условия, при которых первый вариант был бы лучше?

Выделенные темы часто легче рассуждать и могут работать лучше. Это будет работать лучше, если у вас будет небольшое количество потоков.

Если каналы были асинхронными, это может иметь значение?

Да, но это невозможно сказать, если это будет лучше, но это будет сложнее.

Я предлагаю вам взглянуть на netty, если не использовать его, но изучить его подход.