Как эффективно обрабатывать большие объемы данных и избежать избыточных запросов к серверу в 1С?

Мы с вами часто сталкиваемся с ситуацией, когда наша конфигурация 1С начинает "тормозить", а пользователи жалуются на медленную работу. Одной из частых причин такого поведения является слишком большое количество запросов к серверу. Это происходит, когда клиентское приложение слишком часто обращается к серверу для получения или отправки данных, особенно в циклах или при выполнении сложных операций. Давайте вместе разберем, как мы можем оптимизировать взаимодействие клиент-сервер и сделать нашу систему более отзывчивой и производительной.

Основной принцип, которым мы будем руководствоваться, — это минимизация количества серверных вызовов и объема передаваемых данных. Мы хотим, чтобы каждое действие пользователя или программный алгоритм выполнялся с наименьшим числом обращений к серверу, а если обращения неизбежны, то они должны быть максимально эффективными.

Общие принципы оптимизации взаимодействия с сервером

Прежде чем перейти к конкретным механизмам, рассмотрим несколько общих правил, которые помогут нам снизить нагрузку на сервер:

1. Избегайте объектного доступа к данным в циклах. Если нам нужно обработать много элементов, не следует в каждом шаге цикла обращаться к серверу за данными каждого объекта по отдельности. Вместо этого, мы должны предварительно выбрать все необходимые данные одним запросом за пределами цикла. Это значительно снижает количество запросов к серверу базы данных.
2. Не передавайте лишние данные. Нам всегда следует стремиться передавать с клиента на сервер и обратно только те данные, которые абсолютно необходимы для выполнения текущей задачи.
3. Размещайте ресурсоемкие алгоритмы на сервере. Сложные вычисления и объемные обработки лучше выполнять на сервере, обращаясь к ним с клиента минимально необходимое число раз. Серверные машины обычно мощнее клиентских, а веб-клиент, например, исполняет код заметно медленнее.
4. Используйте пакетную обработку. Если нам нужно обработать множество объектов, постарайтесь сделать это одним серверным вызовом, передав сразу весь набор данных или ссылок.

Решение 1: Отложенная обработка на клиенте с помощью Обработчика Ожидания

Представьте ситуацию: нам нужно периодически проверять что-то на сервере или выполнять небольшие порции работы, не блокируя при этом пользовательский интерфейс. Для таких задач на стороне клиента мы можем использовать механизм ПодключитьОбработчикОжидания.

Что такое Обработчик Ожидания?

Это специальный механизм платформы 1С, который позволяет нам указать процедуру для выполнения в "состоянии покоя" системы, то есть когда программа не выполняет никаких активных действий и ждет ввода пользователя. Процедура будет запускаться через заданный интервал времени.

Как мы можем его использовать для снижения нагрузки?

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

1. Подключаем обработчик ожидания на форме, указывая процедуру, которая будет выполнять очередную порцию работы.
2. Внутри этой процедуры мы выполняем вызов сервера для получения небольшой части данных или выполнения части операции.
3. После выполнения работы (или в случае ошибки) мы переподключаем обработчик ожидания с нужной задержкой.

Рассмотрим подробнее пример с динамической задержкой:

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

// Переменные формы
Перем мИнтервалОжидания;
Перем мБазовыйИнтервалОжидания;
Перем мСчетчикПопыток;

&НаКлиенте
Процедура ПриОткрытии(Отказ)
    мБазовыйИнтервалОжидания = 3; // Базовый интервал в секундах
    мИнтервалОжидания = мБазовыйИнтервалОжидания;
    мСчетчикПопыток = 0;
    ПодключитьОбработчикОжидания("ОбработатьПорциюДанныхНаСервере", мИнтервалОжидания);
КонецПроцедуры

&НаКлиенте
Процедура ОбработатьПорциюДанныхНаСервере()
    // Отключаем текущий обработчик, чтобы избежать повторных срабатываний
    ОтключитьОбработчикОжидания("ОбработатьПорциюДанныхНаСервере");

    Попытка
        // Выполняем вызов сервера для обработки очередной порции
        // Например, получаем 500 записей
        Результат = ВызватьСерверДляОбработкиПорции();
        
        Если Результат.Успех Тогда
            // Если успешно, сбрасываем интервал ожидания до базового
            мИнтервалОжидания = мБазовыйИнтервалОжидания;
            мСчетчикПопыток = 0;
            // Здесь обрабатываем полученные данные
            // ...
            Если Результат.ВсеДанныеОбработаны Тогда
                // Если все данные обработаны, больше не подключаем обработчик
                Сообщить("Все данные успешно обработаны.");
            Иначе
                // Если есть еще данные, подключаем обработчик снова с базовым интервалом
                ПодключитьОбработчикОжидания("ОбработатьПорциюДанныхНаСервере", мИнтервалОжидания);
            КонецЕсли;
        Иначе
            // Если произошла ошибка на сервере, увеличиваем интервал ожидания
            мСчетчикПопыток = мСчетчикПопыток + 1;
            мИнтервалОжидания = мИнтервалОжидания + 2 * мСчетчикПопыток; // Увеличиваем на 2, 4, 6... секунды
            Сообщить("Ошибка при обработке порции данных. Повторная попытка через " + мИнтервалОжидания + " секунд.");
            ПодключитьОбработчикОжидания("ОбработатьПорциюДанныхНаСервере", мИнтервалОжидания);
        КонецЕсли;
    Исключение
        // Обработка исключений на клиенте (например, потеря связи)
        мСчетчикПопыток = мСчетчикПопыток + 1;
        мИнтервалОжидания = мИнтервалОжидания + 2 * мСчетчикПопыток;
        Сообщить("Произошла ошибка связи. Повторная попытка через " + мИнтервалОжидания + " секунд. " + ОписаниеОшибки());
        ПодключитьОбрабочикОжидания("ОбработатьПорциюДанныхНаСервере", мИнтервалОжидания);
    КонецПопытки;
КонецПроцедуры

&НаСервереБезКонтекста
Функция ВызватьСерверДляОбработкиПорции()
    // Здесь мы с вами получаем или обрабатываем очередную порцию данных.
    // Например, выбираем 500 записей из базы данных.
    // ...
    Результат = Новый Структура;
    Результат.Вставить("Успех", Истина); // Или Ложь, если произошла ошибка
    Результат.Вставить("ВсеДанныеОбработаны", Ложь); // Или Истина, если обработка завершена
    Возврат Результат;
КонецФункции

Важные моменты при работе с Обработчиком Ожидания:

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

Решение 2: Длительные операции на сервере с помощью Регламентных и Фоновых заданий

Для более длительных и ресурсоемких операций, которые должны выполняться на сервере и не зависеть от активности пользователя на клиенте, мы с вами используем механизм Регламентных и Фоновых заданий. Это идеальное решение, когда нам нужно обрабатывать большие объемы данных, выполнять синхронизации или генерировать отчеты по расписанию.

Что такое Регламентные и Фоновые задания?

• Регламентное задание — это описание задачи, которую необходимо выполнять периодически или однократно по заданному расписанию. Мы настраиваем его в конфигурации или в режиме 1С:Предприятие.
• Фоновое задание — это конкретный экземпляр выполнения регламентного задания или любой другой серверной процедуры, запущенной в фоновом режиме. Оно выполняется незаметно для пользователя, не блокируя его работу.

Как мы можем их использовать для снижения нагрузки?

Представьте, что нам нужно регулярно получать большие объемы данных (например, из ФГИС "Зерно") или обрабатывать множество документов. Вместо того чтобы клиентский компьютер запрашивал эти данные или запускал обработку, мы можем:

1. Создать регламентное задание, которое будет запускаться, например, каждые 2-5 секунд.
2. В процедуре, которую вызывает это регламентное задание, мы будем получать или обрабатывать очередную порцию данных (например, 500 записей), а не все сразу.

Преимущества этого подхода:

• Не блокирует клиентский интерфейс: Пользователь может продолжать работать, пока на сервере выполняется фоновая обработка.
• Балансировка нагрузки: В клиент-серверном варианте фоновые задания распределяются планировщиком заданий на наименее загруженные рабочие процессы кластера, что способствует оптимальному использованию ресурсов сервера.
• Автономность: Задания выполняются независимо от того, запущен ли клиент 1С вообще.

Пример использования:

Мы с вами можем создать экспортную процедуру в общем модуле, которая будет вызываться регламентным заданием:

// Общий модуль, например, "РаботаСДаннымиСервер" с галочкой "Сервер" и "ВызовСервера"
// и "Глобальный" (если это необходимо)

Процедура ОбработатьОчереднуюПорциюДанных() Экспорт
    // Здесь мы с вами должны определить, какую порцию данных нужно обрабатывать
    // и сохранить состояние между вызовами.
    // Это может быть регистр сведений, где хранится последний обработанный ID,
    // или специальный объект для управления фоновой очередью.

    // Пример: получаем 500 необработанных записей
    Запрос = Новый Запрос;
    Запрос.Текст = 
        "ВЫБРАТЬ ПЕРВЫЕ 500
        |    ДанныеДляОбработки.Ссылка
        |ИЗ
        |    Документ.МойДокумент КАК ДанныеДляОбработки
        |ГДЕ
        |    НЕ ДанныеДляОбработки.Обработан"; // Предположим, есть флаг "Обработан"

    Выборка = Запрос.Выполнить().Выбрать();

    Пока Выборка.Следующий() Цикл
        // Обрабатываем текущую запись
        Объект = Выборка.Ссылка.ПолучитьОбъект();
        // ... выполняем нужные действия с объектом ...
        Объект.Обработан = Истина;
        Объект.Записать();
    КонецЦикла;

    // Если все данные обработаны, регламентное задание можно временно отключить
    // или оно будет просто запускаться вхолостую до появления новых данных.
КонецПроцедуры

Далее мы регистрируем это задание в конфигурации или через программный интерфейс, указывая расписание запуска. Например, каждые 5 секунд.

Важный совет: Если функциональность, за которую отвечает регламентное задание, временно не нужна или отключена в программе, мы должны отключать и само задание, чтобы не расходовать вычислительные ресурсы сервера 1С:Предприятие.

Решение 3: Асинхронное программирование (для платформы 8.3.18+)

С платформы 1С:Предприятие версии 8.3.18 у нас появилась мощная возможность для написания неблокирующего кода на клиенте — асинхронное программирование с использованием ключевых слов Асинх и Ждать (Async / Await).

Что это такое?

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

Когда это особенно полезно?

• При работе с внешними веб-сервисами, которые могут долго отвечать.
• При выполнении сложных расчетов, которые не должны блокировать интерфейс.
• При обработке больших объемов данных, когда мы не хотим использовать ПодключитьОбработчикОжидания с его ограничениями.
• При операциях с файловой системой клиентского компьютера в веб-клиенте (они часто могут быть только асинхронными).

Пример использования:

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

&НаКлиенте
Процедура ПолучитьДанныеАсинхронно(Команда)
    Сообщить("Начинаем получать данные... Интерфейс не заблокирован.");
    
    // Вызываем асинхронную серверную процедуру
    Ждать ВызватьСерверДляПолученияБольшихДанныхАсинх();
    
    Сообщить("Данные получены и обработаны!");
КонецПроцедуры

&НаСервереАсинх
Функция ВызватьСерверДляПолученияБольшихДанныхАсинх()
    // Эта процедура выполняется на сервере асинхронно.
    // Она может содержать длительные операции, например,
    // выборку большого объема данных или обращение к внешнему API.
    
    // Имитация длительной операции
    Пауза(10); // Пауза на 10 секунд
    
    // ... логика получения и обработки данных ...
    
    // Возвращаем результат, если необходимо
    Возврат "Успешно";
КонецФункции

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

Дополнительные методы оптимизации запросов и обработки данных

Помимо рассмотренных механизмов, мы с вами можем применить и другие техники для снижения количества запросов и повышения производительности:

Пакетная обработка и оптимизация запросов

1. Используйте ВыбратьПоСсылкам(). Для массовой обработки объектов по набору ссылок в платформе 1С планируется реализовать метод ВыбратьПоСсылкам() у менеджеров объектов. Это позволит нам получить выборку данных сразу многих объектов за одно обращение к базе данных, вместо многократных ПолучитьОбъект().
2. Оптимизируйте тексты запросов.
   • Избегайте ВЫБРАТЬ *. Всегда явно указывайте поля, которые вам нужны. Выбор всех полей, особенно в больших таблицах, увеличивает объем передаваемых данных.
   • Используйте индексы. Для полей, по которым часто происходит поиск, сортировка или соединение таблиц, убедитесь, что созданы индексы. Это значительно ускоряет выполнение запросов.
   • Разбивайте сложные запросы. Если запрос слишком сложен, использует много виртуальных таблиц или подзапросов, рассмотрите возможность его разбиения на несколько более простых запросов с использованием временных таблиц (ключевое слово ПОМЕСТИТЬ).

Взаимодействие с внешними системами

Опыт работы с такими системами, как ФГИС "Зерно", показывает, что контролируемое взаимодействие является ключом к успеху. Мы должны:

• Использовать счетчики и задержки между вызовами, как мы рассмотрели в примере с ОбработчикОжидания. Это помогает избежать перегрузки внешнего сервиса и блокировки наших запросов.
• Предпочитать пакетную передачу данных. Вместо того чтобы отправлять каждый документ по отдельности, собирайте их в пакеты и отправляйте за один запрос.
• Активно использовать регламентные задания для периодического обмена данными с внешними системами, особенно для длительных операций или получения больших объемов информации.

Мы с вами разобрали различные подходы к решению проблемы избыточных запросов к серверу в 1С. Выбор конкретного метода зависит от специфики задачи: для клиентских фоновых операций с небольшой задержкой подойдет ОбработчикОжидания; для длительных серверных задач, выполняющихся по расписанию, — Регламентные и Фоновые задания; а для современного неблокирующего клиент-серверного взаимодействия — Асинхронное программирование. Комбинируя эти подходы и следуя общим принципам оптимизации, мы сможем значительно улучшить производительность и отзывчивость наших систем 1С.