О чем это я...
При построении высоко нагруженной распределенной системы на основе WCF, одной из важнейших проблем является поддержание работоспособности системы под определенной нагрузкой.Под нагрузкой в данном случае я понимаю некое (большое) количество параллельных запросов к сервису - то количество, которое определено какими-то требованиями. То есть если требования гласят, что получение ответа от сервиса должно произойти в течении 0,1 секунды, то именно в такие рамки нужно уложиться независимо от количества параллельных запросов.
Для балансировки нагрузки на сервис есть множество приемов, та же кластеризация, но эта тема выходит за рамки данной статьи.
Задача этой статьи состоит в том, чтобы описать возможные "пробки", в которые могут попасть сообщения между клиентом и сервисом в контексте WCF.
Собственно от очевидного к невероятному:
- Атрибут ConcurrencyMode
- Элемент конфигурации serviceThrottling - настройка "заслонок"
- Самое интересное - ThreadPool.SetMinThreads()
- Самое невероятное - атрибут maxConnection в секции system.net/connectionManagement
- Редкий, но возможный кейс - один клиентский канал для нескольких потоков
Пробка 1. ServiceBehavior.ConcurrencyMode != ConcurrencyMode.Multiple
Распараллеливание обработки запросов сервисом начинается с установки параметра ConcurrencyMode атрибута ServiceBehavior в значение Mutiple - на каждый запрос к сервису будет выделяться поток из пула. Если установлено значение Single или Reentrant (только для работы с сессиями) - все запросы будут обрабатываться в единственном потоке, про асинхронность можно забыть.
[ServiceBehavior(
ConcurrencyMode = ConcurrencyMode.Multiple,
InstanceContextMode = InstanceContextMode.Single)]
public class Service: IService
{
// реализация
}
Также атрибут ServiceBehavior имеет параметр InstanceContextMode, который отвечает за способ создания экземпляров сервиса. PerCall - экземпляр сервиса будет создаваться на каждый вызов, PerSession - на каждую сессию (сессии в этой статье не обсуждаются), Single - этакий синглтон, создается один раз, используется один экземпляр на все время жизни сервиса. Выбор значения должен основываться на специфике работы сервиса. Например, если инициализация сервиса - довольно затратная операция, то правильнее будет использовать значение Single, чтобы не тратить каждый раз время на создание и инициализацию нового экземпляра сервиса.
Не стоит забывать и о настройках "заслонок" (throttling) - они позволяют регулировать нагрузку на сервис с помощью атрибутов maxConcurrentCalls, maxConcurrentInstances и maxConcurrentSessions (последний вне скоупа данной статьи - сессии мы не рассматриваем).
Атрибут maxConcurrentCalls отвечает за максимальное количество одновременно обрабатываемых запросов к сервису, maxConcurrentInstances - количество одновременно инстанцируемых экземпляров сервиса для обработки параллельных запросов.
Дефолтные значения этих атрибутов зависят от версии .Net Framework.
Пробка 2. Конфигурация сервиса - serviceThrottling
Не стоит забывать и о настройках "заслонок" (throttling) - они позволяют регулировать нагрузку на сервис с помощью атрибутов maxConcurrentCalls, maxConcurrentInstances и maxConcurrentSessions (последний вне скоупа данной статьи - сессии мы не рассматриваем).
Атрибут maxConcurrentCalls отвечает за максимальное количество одновременно обрабатываемых запросов к сервису, maxConcurrentInstances - количество одновременно инстанцируемых экземпляров сервиса для обработки параллельных запросов.
Дефолтные значения этих атрибутов зависят от версии .Net Framework.
- До 4.0
- maxConcurrentCalls = 16
- maxConcurrentSessions = 10
- maxConcurrentInstances = maxConcurrentCalls + maxConcurrentSessions = 26
- Начиная с 4.0
- maxConcurrentCalls = 16 * количество процессоров
- maxConcurrentSessions = 100 * количество процессоров
- maxConcurrentInstances = maxConcurrentCalls + maxConcurrentSessions
Пример конфигурации:
<behavior name="ServiceBehavior">
<serviceThrottling maxConcurrentCalls="2000" />
</behavior>
Таким образом, имея сервер с 16 процессорами, без явного указания в конфигурации значений "заслонок" мы можем рассчитывать максимум на 256 (16*16) параллельных потоков в .Net 4.0 и выше, и на 16 потоков в предыдущих версиях. Я думаю никто не поспорит с тем, что для высоко нагруженных систем данные цифры маловаты.
Пробка 3. WCF использует ThreadPool, и это хорошо, но есть такой момент...
WCF на стороне сервиса использует управляемые потоки ввода-вывода (Managed IO threads) для обработки запросов - соответственно использует ThreadPool. А фишка в том, что ThreadPool охраняет от убивания ограниченное количество IO потоков. По умолчанию это количество опять таки зависит от количества процессоров и его можно получить с помощью ThreadPool.GetMinThreads. На моем компьютере 4 ядра, и метод выдает 4 потока.
Как только WCF выдергивает все доступные потоки из пула, и запрашивает следующий, вступает в действие ограничение в полсекунды между созданием потоков.
Представьте себе сервис, на каждом запросе достающий данные из БД. Если к нему будет произведено одновременно 100 запросов, то 4 из них выполнятся одновременно, а остальные будут запускаться с задержкой в полсекунды.
Для того, чтобы избежать пробки на этом этапе, необходимо увеличить минимальное количество потоков в ThreadPool, с помощью метода ThreadPool.SetMinThreads (кстати есть известный баг в .Net 3.5, там этот метод работает не так как надо, в связи с чем Microsoft выпустили hotfix).
Пробка 4. Редкий кейс - один многопоточный клиент общается с сервисом по http-каналу...
Очень специфичная ситуация возникла на одном из проектов, где я принимал участие. У нас был один WCF сервис, получающий данные из БД и подготавливающий их, и один сервер приложений, который и был собственно клиентом сего WCF сервиса. При этом сервер приложений подразумевал довольно таки большое количество одновременных запросов. После всех вышеописанных настроек, WCF сервис все равно продолжал затыкаться на некотором небольшом количестве запросов от сервера приложений, время ответа возрастало, нагрузочные тесты падали.
В итоге поиски решения привели к настройке максимального количества HTTP-соединений на стороне клиента. А именно атрибут maxConnection в секции system.net/connectionManagement
<system.net>
<connectionManagement>
<add address="http://server.domain.org" maxconnection="100"/>
</connectionManagement>
</system.net>
В MSDN написано: если атрибут явно не указан, используется значение по умолчанию - 2. Т.е. количество http-соединений от клиента к серверу ограничено двумя, и это конечно мало.
Пробка 5. Еще один редкий случай - Один клиентский канал используемый сразу из нескольких потоков
Я думаю этот случай - тема отдельной статьи, поскольку здесь придется влезть поглубже в недра WCF, а в данной статье я опишу как его воспроизвести, и как от него избавиться.
Вот такой код:
const int threadCount = 100;
// Канал создается в основном потоке
var proxy = ChannelFactory<IService>.CreateChannel(
new BasicHttpBinding(),
new EndpointAddress(newUri(serviceAddress)))
var squares = new ConcurrentBag<Double>();
var squareComputations = Enumerable.Range(1, threadCount)
.Select(i => new Thread(() => squares.Add(proxy.Multiplication(i, i))))
.ToList();
squareComputations.ForEach(thread => thread.Start());
squareComputations.ForEach(thread => thread.Join());
Как видно, канал (proxy) создается до создания и запуска потоков. В данном случае происходит "затык" - на сервере все запросы встают в некую магическую очередь. Возникает ощущение, что в момент первого вызова, происходит блокирование какого-то ресурса, и остальные потоки на нем "залипают".
Избавиться от такого поведения можно двумя способами:
- сделать первоначальный запрос к сервису через созданный канал cинхронно
- создавать отдельный канал в каждом потоке
Код для первого случая:
const int threadCount = 100;
var proxy = ChannelFactory<IService>.CreateChannel(
new BasicHttpBinding(),
new EndpointAddress(newUri(serviceAddress)))
// делаем синхронный вызов метода сервиса.
// после этого все вызовы из параллельных потоков
// будут обрабатываться параллельно
var result = proxy.Multiplication(2, 2);
var squares = new ConcurrentBag<Double>();
var squareComputations = Enumerable.Range(1, threadCount)
.Select(i => new Thread(() => squares.Add(proxy.Multiplication(i, i))))
.ToList();
squareComputations.ForEach(thread => thread.Start());
squareComputations.ForEach(thread => thread.Join());
Для второго случая:
const int threadCount = 100;
var squares = new ConcurrentBag<Double>();
var squareComputations = Enumerable.Range(1, threadCount)
.Select(i => new Thread(() =>
{
// Создаем канал в каждом потоке
var proxy = ChannelFactory<IService>.CreateChannel(
new BasicHttpBinding(),
new EndpointAddress(newUri(serviceAddress)))
squares.Add(proxy.Multiplication(i, i));
))
.ToList();
squareComputations.ForEach(thread => thread.Start());
squareComputations.ForEach(thread => thread.Join());