DEADLOCK в 1С и POSTGRESQL: как найти и устранить взаимоблокировки в большой базе
Когда проведение документов превращается в лотерею
10:17. В производственной системе 1С:ERP начинают появляться ошибки при проведении документов. Одни операции завершаются нормально, другие — после продолжительного ожидания. Некоторые пользователи повторяют проведение и получают тот же результат. Вскоре сообщения о проблеме поступают из нескольких подразделений.
Администратор проверяет сервер PostgreSQL. Процессор не загружен до предела, свободной оперативной памяти достаточно, дисковое пространство не заканчивается. База данных принимает подключения, обычные запросы выполняются, приложение доступно.
Тем не менее проводить документы становится сложнее.
В такой ситуации есть соблазн увеличить тайм-ауты, перезапустить службу или временно ограничить количество пользователей. Эти меры могут изменить проявление проблемы, но не обязательно устранят её причину.
Для начала нужно ответить на вопрос: что именно происходит с транзакциями?
Возможны разные сценарии:
- запрос действительно долго выполняется;
- транзакция ждёт освобождения блокировки, удерживаемой другой транзакцией;
- несколько транзакций образовали цикл взаимных ожиданий;
- операция задерживается на уровне механизмов блокировок 1С;
- приложение ожидает соединение или ответ зависимого компонента, а блокировка возникает уже как следствие продолжительного выполнения;
- после ошибки система повторяет операции, увеличивая конкуренцию за одни и те же данные.
Внешне эти ситуации похожи. Пользователь видит сообщение об ошибке или долго ждёт завершения операции. Но инженерные действия в каждом случае будут разными.
Deadlock — это цикл ожиданий, при котором каждая из участвующих транзакций удерживает ресурс, необходимый другой. Продолжить работу в таком состоянии без отмены одной из конфликтующих транзакций невозможно.
PostgreSQL обнаруживает взаимоблокировку и прерывает одну из транзакций. Это штатное поведение СУБД: сервер не позволяет взаимному ожиданию продолжаться бесконечно.
Но штатная реакция PostgreSQL не означает, что проблема штатна для предприятия. Если взаимоблокировки возникают при обычном проведении документов, приложение может регулярно сталкиваться с отменами операций, повторными попытками и задержками бизнес-процессов.
Здесь важно сразу разделить две задачи:
- Обнаружить и правильно классифицировать инцидент.
- Устранить условия, при которых конфликтующие операции снова и снова образуют цикл.
Первая задача решается средствами диагностики. Вторая требует понимания транзакционной логики приложения.
И именно на втором этапе становится понятно, почему простого администрирования сервера часто недостаточно.
Почему нельзя считать блокировки 1С и PostgreSQL одним и тем же
В информационной системе на платформе 1С, использующей PostgreSQL, действуют несколько механизмов обеспечения согласованности данных. Их взаимодействие необходимо учитывать при расследовании.
Если не разделить эти уровни, можно потратить много времени на анализ PostgreSQL, хотя проблема возникает в прикладной логике блокировок 1С. Возможна и обратная ситуация: прикладные блокировки выглядят нормально, но две транзакции образуют цикл уже внутри СУБД.
Блокировки платформы 1С
Платформа 1С предоставляет собственные механизмы блокировок, в том числе управляемые блокировки, предназначенные для координации параллельной работы с прикладными данными.
Например, при проведении документов нескольким пользователям может потребоваться изменить данные, связанные с одним складом, номенклатурой или производственным заказом. Прикладная логика должна обеспечить, чтобы конкурентные операции не нарушили правила учёта.
Управляемая блокировка может относиться к логической области данных, определяемой объектом метаданных и значениями ключевых полей. Это не обязательно одна физическая строка PostgreSQL.
Важны не только сами блокировки, но и то, когда они устанавливаются, на какой срок удерживаются и какие другие действия выполняются внутри транзакции.
Если прикладной алгоритм блокирует слишком широкую область данных, операции, которые могли бы выполняться параллельно, начинают мешать друг другу. Если последовательность захвата блокировок различается в разных сценариях, появляется риск конфликтов.
Однако даже корректно организованные управляемые блокировки не исключают всех возможных взаимоблокировок внутри СУБД.
Блокировки PostgreSQL
PostgreSQL обеспечивает согласованность операций на уровне базы данных. При изменении строк, работе с таблицами и выполнении других операций СУБД использует собственные механизмы блокировок.
Рассмотрим два изменения:
- транзакция A обновляет запись X, затем пытается изменить Y;
- транзакция B обновляет Y, затем пытается изменить X.
Если каждая транзакция уже удерживает блокировку на своей записи, вторая операция каждой из них может оказаться заблокированной.
Возникает цикл взаимного ожидания. PostgreSQL обнаруживает его и отменяет одну из транзакций.
При этом физические таблицы и запросы в реальной базе 1С могут быть гораздо сложнее условной модели. Одна операция проведения способна затрагивать несколько наборов данных, а конфликт может возникнуть не там, где разработчик ожидает его увидеть.
Почему одного журнала недостаточно
Технологический журнал 1С помогает восстановить контекст выполнения прикладной операции. Журнал PostgreSQL позволяет исследовать события на уровне СУБД, включая обнаруженные взаимоблокировки.
Эти источники дополняют друг друга.
Если PostgreSQL зарегистрировал deadlock detected, это прямое свидетельство обнаружения взаимоблокировки внутри СУБД. Но оно само по себе не объясняет, почему прикладные операции пришли к конфликтующим ресурсам в таком порядке.
Если технологический журнал показывает ожидание блокировки 1С, это ещё не означает, что PostgreSQL обнаружил deadlock. Причина может находиться в другом механизме.
Поэтому нельзя автоматически приравнивать любое сообщение о блокировке в 1С к взаимоблокировке PostgreSQL. И нельзя считать отсутствие deadlock detected доказательством того, что проблема блокировок отсутствует: продолжительные ожидания могут возникать без циклов.
Первый этап расследования — установить, какой именно механизм проявился в конкретном инциденте.
Как две нормальные операции создают ненормальную ситуацию
Разберём модельный сценарий, характерный для систем, в которых одновременно выполняются операции над связанными данными.
Предположим, в 1С:ERP одновременно обрабатываются два документа. Первый обновляет данные складского учёта, а затем обращается к связанным данным производственного заказа. Второй начинает с изменения производственного заказа, а затем обращается к данным складского учёта.
Это упрощённая модель. Она иллюстрирует механизм взаимоблокировки, но не утверждает, что в каждой конфигурации 1С документы выполняют именно такие действия или что физические таблицы базы имеют подобную структуру.
Обозначим две конфликтующие записи X и Y.
До момента конфликта обе операции могли выполняться совершенно штатно. Каждая получила необходимую ей блокировку и продолжила работу. Проблема возникла из-за сочетания времени выполнения и порядка обращения к ресурсам.
Важное следствие: deadlock не обязательно означает, что один запрос написан неправильно или что сервер не справляется с нагрузкой.
Он может быть следствием взаимодействия нескольких корректных по отдельности операций.
При этом чем выше конкуренция за одни и те же данные, тем больше вероятность столкновения. Но рост нагрузки лишь увеличивает вероятность конфликта — он не объясняет, почему транзакции вообще способны образовать цикл.
Почему виноват не обязательно тот запрос, который завершился ошибкой
Предположим, PostgreSQL отменил транзакцию A.
Пользователь видит ошибку проведения документа A. Естественная реакция — искать дефект в этом документе.
Но транзакция B тоже участвовала в цикле. Если изменить только операцию A, не понимая поведения B, конфликт может сохраниться или появиться в другой комбинации операций.
Кроме того, PostgreSQL прерывает одну из транзакций, чтобы разорвать цикл. Выбор участника для отмены не означает, что именно эта транзакция является первопричиной с точки зрения бизнес-логики.
Нужно исследовать обе стороны взаимоблокировки:
- какие ресурсы каждая транзакция успела захватить;
- какие ресурсы она пыталась получить далее;
- какие прикладные действия соответствуют этим запросам;
- почему последовательности доступа различаются;
- можно ли устранить конфликт изменением порядка операций или структуры транзакций.
Только после этого можно выбирать исправление.
Как прочитать сообщение о deadlock и не сделать преждевременный вывод
Журнал PostgreSQL — один из главных источников информации о взаимоблокировках. При обнаружении цикла сервер обычно записывает ошибку:
В диагностическом сообщении могут присутствовать сведения о процессах, ожидающих блокировки друг друга, типах ресурсов, участвующих транзакциях и SQL-операторах.
Рассмотрим условный фрагмент, построенный по типичной структуре сообщения PostgreSQL:
ERROR: deadlock detected DETAIL: Process 18421 waits for ShareLock on transaction 92014; blocked by process 18436. Process 18436 waits for ShareLock on transaction 92015; blocked by process 18421. HINT: See server log for query details.
Идентификаторы и номера транзакций здесь вымышлены. Это пример формата сообщения, а не журнал реального инцидента.
Разберём, что из него можно установить.
Первое: PostgreSQL действительно обнаружил deadlock. Это уже не предположение, основанное на жалобах пользователей или длительном времени ответа.
Второе: в цикле участвуют два процесса. Процесс 18421 ждёт завершения транзакции, связанной с процессом 18436. Второй процесс, в свою очередь, ждёт завершения транзакции первого.
Третье: указанный ShareLock относится к ожиданию блокировки идентификатора транзакции. В типичном сценарии конкурентного изменения строк PostgreSQL может ждать завершения другой транзакции, которая удерживает конфликтующую блокировку на данных.
Здесь есть важный нюанс. ShareLock on transaction ... не означает, что приложение явно выполнило SQL-команду блокировки таблицы в режиме SHARE. Это внутренний механизм ожидания, который нужно интерпретировать вместе с контекстом конфликта.
Четвёртое: сообщение не раскрывает бизнес-причину. Оно показывает механизм взаимного ожидания, но не объясняет, почему два документа в 1С изменяли данные в таком порядке.
Чтобы перейти к первопричине, необходимо получить сведения о запросах, участвовавших в цикле, и связать их с операциями приложения.
Что ещё необходимо извлечь из журнала
При расследовании нужно сохранить полное сообщение об ошибке, включая все доступные поля DETAIL, CONTEXT, STATEMENT и связанные записи журнала.
Не следует ограничиваться одной строкой deadlock detected: именно дополнительные сведения часто позволяют определить конфликтующие ресурсы.
Для идентификации процессов полезно иметь информативный префикс журнала PostgreSQL. Например, конфигурация может включать время, PID, имя приложения и идентификатор сессии:
log_line_prefix = '%m [%p] %a %c 'Здесь %m — временная метка, %p — PID процесса, %a — имя приложения, %c — идентификатор сессии.
Такой префикс облегчает сопоставление записей одного процесса. Но он не создаёт автоматической связи между PID PostgreSQL и конкретным документом 1С. Эту связь необходимо восстанавливать по времени, контексту выполнения и данным технологического журнала.
Также следует учитывать, что диагностические сведения зависят от версии PostgreSQL, настроек журналирования и характера конфликта. Если текст запросов отсутствует, нельзя просто предположить, что оба процесса выполняли именно те операции, которые ожидаются по прикладной логике.
Как перейти от PID PostgreSQL к конкретной операции 1С
PostgreSQL способен показать, какие процессы участвовали во взаимоблокировке. Но сам по себе он не знает, что пользователь проводил поступление материалов, выполнял закрытие месяца или запускал регламентную обработку.
Чтобы установить бизнес-контекст, необходимо обратиться к технологическому журналу 1С.
Для этого сначала определяют временной интервал, в котором PostgreSQL зарегистрировал deadlock. Затем ищут события технологического журнала, относящиеся к соответствующим процессам, соединениям и операциям.
Важны не только конечные ошибки, но и последовательность событий до них:
- начало и продолжительность прикладной операции;
- обращения к СУБД;
- ожидания блокировок, если они фиксируются используемой конфигурацией журналирования;
- исключения и завершение операции;
- доступные идентификаторы процессов и соединений.
Конкретные имена событий и набор полей зависят от версии платформы, используемых механизмов и настроек технологического журнала. Поэтому диагностическую конфигурацию необходимо проверять на той версии 1С, которая используется в системе, а не копировать универсальный список параметров без проверки.
Как связать два журнала
Предположим, PostgreSQL сообщает о deadlock в 10:17:42 и указывает процессы 18421 и 18436.
В технологическом журнале обнаруживаются две операции, выполнявшиеся в тот же временной интервал. Их связь с процессами PostgreSQL необходимо подтвердить по доступным идентификаторам и контексту выполнения. Одна связана с проведением складского документа, другая — с обработкой производственного заказа.
Это уже полезная информация, но временного совпадения недостаточно.
Нужно проверить:
- Действительно ли найденные операции выполнялись в указанный момент.
- Соответствуют ли они соединениям или процессам, участвовавшим в конфликте.
- Какие SQL-операторы выполнялись в рамках этих операций.
- Можно ли восстановить порядок обращений к данным.
- Повторяется ли такая последовательность в других инцидентах.
Если идентификаторов для прямого сопоставления недостаточно, связь восстанавливают по совокупности признаков. При этом вывод следует обозначать как подтверждённый или предварительный в зависимости от качества данных.
Например, два события в одну секунду ещё не доказывают, что одно относится к процессу 18421, а другое — к 18436. В нагруженной системе одновременно могут работать десятки похожих операций.
Для будущих расследований полезно заранее организовать журналирование так, чтобы сохранялись необходимые идентификаторы и контекст. Исправить недостаток наблюдаемости после возникновения инцидента гораздо сложнее, чем подготовить систему заранее.
Почему важно исследовать успешные выполнения
Допустим, удалось найти документ, проведение которого завершилось deadlock.
Следующий шаг — сравнить его с успешным выполнением того же сценария.
Возможно, при обычной нагрузке операция обращается к данным в определённом порядке, но дополнительная ветвь логики меняет последовательность в редком случае. Или конфликт возникает только тогда, когда одновременно выполняется конкретное регламентное задание.
Сравнение успешного и неуспешного выполнения позволяет сформировать более точную гипотезу, чем изучение одной ошибки.
В этом и состоит разница между поиском сообщения об инциденте и расследованием его причины.
Как исследовать блокировки, пока проблема происходит
Журнал PostgreSQL помогает восстановить уже произошедшую взаимоблокировку. Если проблема повторяется, полезно одновременно наблюдать состояние базы во время инцидента.
Начать можно с представления pg_stat_activity:
SELECT pid, application_name, state, wait_event_type, wait_event, xact_start, query_start, now() - query_start AS query_age, left(query, 200) AS query_sample FROM pg_stat_activity WHERE datname = current_database() AND state IS DISTINCT FROM 'idle' ORDER BY query_start NULLS LAST;
Этот запрос позволяет увидеть активные сессии, типы ожиданий, время начала транзакции и текущего запроса.
Но есть важное ограничение: длительность запроса не равна времени ожидания блокировки.
Запрос может выполняться долго по множеству причин, а транзакция может удерживать ресурсы даже после завершения отдельного SQL-оператора.
Особенно внимательно следует смотреть на состояние idle in transaction. Оно означает, что сессия находится внутри открытой транзакции, но в данный момент не выполняет запрос. Такая транзакция всё ещё может удерживать блокировки.
Следующий шаг — определить, кто кого блокирует. Для этого используется pg_blocking_pids().
SELECT waiting.pid AS waiting_pid, waiting.application_name AS waiting_app, waiting.wait_event_type, waiting.wait_event, now() - waiting.query_start AS query_age, blocking.pid AS blocking_pid, blocking.application_name AS blocking_app, blocking.state AS blocking_state, blocking.xact_start AS blocking_xact_start, now() - blocking.xact_start AS blocking_xact_age, left(waiting.query, 160) AS waiting_query, left(blocking.query, 160) AS blocking_query FROM pg_stat_activity AS waiting CROSS JOIN LATERAL unnest(pg_blocking_pids(waiting.pid)) AS blocker(pid) JOIN pg_stat_activity AS blocking ON blocking.pid = blocker.pid WHERE waiting.datname = current_database() ORDER BY waiting.query_start NULLS LAST;
Запрос показывает текущие отношения блокирования. Он помогает найти процесс, который непосредственно мешает другой сессии получить блокировку.
Но это не готовый детектор всех deadlock за выбранный период. После того как PostgreSQL обнаружил цикл и отменил одну из транзакций, исходная структура ожиданий может исчезнуть. Поэтому уже завершившийся инцидент следует исследовать по журналу, а текущие представления использовать для наблюдения за активными ожиданиями.
Как интерпретировать результат
Предположим, запрос показывает:
- сессия A ожидает блокировку;
- сессия B непосредственно блокирует A;
- транзакция B открыта значительно дольше, чем длится её текущий запрос.
Это указывает на необходимость изучить транзакцию B.
Возможно, она выполняет продолжительную операцию. Возможно, она находится в idle in transaction и удерживает ресурсы после завершения SQL-команды.
Но делать вывод, что B является первопричиной всех проблем, пока рано. Она может быть блокирующей стороной одного ожидания, а в другом сценарии сама ждать другую транзакцию.
Нужно восстановить всю цепочку ожиданий и проверить, образуется ли цикл.
Для этого исследуют блокирующие связи, связанные запросы и журналы. Представление pg_locks помогает дополнительно изучить типы ресурсов и режимы блокировок.
Не следует пытаться определить конфликт только по совпадению идентификаторов строк или таблиц в pg_locks: модель блокировок PostgreSQL сложнее, а ожидания могут относиться к идентификаторам транзакций и другим ресурсам.
И ещё один важный момент: блокирующий процесс не обязательно выполняет тот запрос, который первоначально получил блокировку. Он мог получить её раньше и перейти к другому действию, сохраняя открытую транзакцию.
Поэтому исследовать нужно не только текущий SQL, но и жизненный цикл транзакции.
Почему взаимоблокировка возникает именно в этой системе
Когда известны процессы, участвовавшие в deadlock, начинается основная инженерная работа.
Необходимо объяснить не просто факт конфликта, а условия, при которых он стал возможен.
Рассмотрим несколько типичных механизмов.
Разный порядок доступа к одним и тем же данным
Это классический сценарий взаимоблокировки.
Одна операция получает блокировку A, затем B. Другая получает B, затем A. При совпадении по времени возникает цикл.
Исправление может заключаться в приведении порядка доступа к единому правилу. Но в 1С это не всегда означает переставить местами два оператора.
Последовательность работы с данными может складываться из нескольких процедур, движений документов, проверок, вызовов общих модулей и обращений к зависимым объектам.
Поэтому анализировать нужно полный путь выполнения операции, а не только последний SQL-запрос из журнала.
Если одна ветвь прикладной логики получает блокировки в порядке A → B, а другая — B → A, локальное исправление одной процедуры может не решить проблему, если аналогичная последовательность сохраняется в другом месте.
Слишком широкая область блокировки
Иногда приложение блокирует больше данных, чем действительно необходимо для выполнения операции.
Это может происходить из-за выбранной области управляемой блокировки, состава ключевых полей или особенностей алгоритма проведения.
В результате две операции, которые могли бы работать параллельно с независимыми данными, начинают конкурировать за одну область блокировки.
Уменьшение области блокировки способно повысить параллелизм. Но такое изменение требует особенно внимательной проверки: если блокировка обеспечивала целостность бизнес-операции, её чрезмерное сужение может привести к некорректным данным.
Поэтому задача не в том, чтобы блокировать как можно меньше. Нужно блокировать ровно ту область, которая необходима для соблюдения правил учёта.
Продолжительные транзакции
Чем дольше транзакция удерживает конфликтующие ресурсы, тем больше времени другие операции могут ожидать их освобождения.
Причиной могут быть массовые изменения, избыточные запросы внутри транзакции, ожидание внешнего компонента или выполнение действий, которые не требуют удержания блокировок.
Но простое сокращение транзакции не всегда безопасно.
Если разбить атомарную операцию на несколько независимых фиксаций, при сбое часть данных может остаться изменённой, а другая — нет. Для прикладной системы это может оказаться хуже исходного deadlock.
Поэтому сначала необходимо определить границы бизнес-операции и понять, какие действия должны выполняться атомарно.
Затем можно искать возможность сократить критическую секцию, подготовить часть данных заранее или изменить последовательность действий, сохранив требования к согласованности.
Фоновые задания и пользовательские операции
Регламентные задания, обмены и массовые обработки могут обращаться к тем же данным, что и пользовательские документы.
Если фоновый процесс одновременно обновляет большое количество записей, он способен увеличить конкуренцию в период пиковой нагрузки.
Здесь полезно сопоставить время возникновения deadlock с расписанием заданий и составом операций.
Если конфликты повторяются только при одновременном выполнении определённого задания и конкретного типа документов, это сильная диагностическая подсказка.
Но перенос задания на ночь не всегда является окончательным решением. Он может снизить вероятность столкновения, однако не устраняет саму несовместимость последовательностей доступа. Кроме того, при росте объёма данных проблема может вернуться.
Более устойчивое решение может потребовать ограничения параллелизма, обработки данных порциями или изменения алгоритма фоновой обработки.
Повторные попытки, усиливающие конфликт
После ошибки пользователь может повторить проведение. Автоматизированный механизм тоже может запускать операцию повторно.
Если повтор происходит немедленно, несколько операций могут снова столкнуться за те же ресурсы.
В результате система начинает расходовать дополнительные ресурсы на действия, которые не приближают её к завершению работы.
Повторные попытки должны быть ограничены, учитывать тип ошибки и выполняться только после корректного завершения неуспешной транзакции.
SQLSTATE: 40P01 (deadlock_detected)
Для PostgreSQL код ошибки взаимоблокировки — SQLSTATE 40P01. Его можно использовать для классификации ошибки на соответствующем уровне приложения, если код доступен через используемый драйвер и слой обработки.
Однако автоматический повтор не должен заменять исправление устойчивого дефекта конкурентной логики.
Если deadlock возникает постоянно, система будет регулярно отменять и запускать заново операции, увеличивая нагрузку и ухудшая предсказуемость работы.
Как устранить причину и не нарушить целостность данных
После восстановления последовательности событий необходимо сформулировать конкретную гипотезу.
«Два вида документов обновляют связанные данные в разном порядке. При одновременном выполнении каждая транзакция удерживает блокировку, необходимую другой. PostgreSQL обнаруживает цикл и отменяет одну из операций».
Это уже проверяемое объяснение. Оно предсказывает, при каком сочетании операций проблема должна повторяться и какое изменение способно повлиять на результат.
Дальше нужно рассмотреть возможные исправления.
Если конфликт действительно вызван разным порядком доступа, можно привести последовательность операций к единому правилу. Но исправление должно охватывать все значимые ветви прикладной логики. Если порядок изменён только в одном месте, другая процедура может продолжить создавать тот же цикл. После изменения нужно проверить не только исходную пару документов, но и другие операции, которые обращаются к тем же данным.
Если транзакция выполняет лишнюю работу, следует выяснить, какие действия можно вынести за её пределы. Это могут быть подготовительные вычисления, получение данных, не требующих транзакционной защиты, или другие операции, которые допустимо выполнять до начала критического участка. Однако перенос действий за границы транзакции безопасен только при сохранении необходимых гарантий. В противном случае между подготовкой данных и их фиксацией может измениться состояние системы.
Если конфликт связан с чрезмерно широкой областью блокировки, следует исследовать её ключи, режим и момент установки. Иногда корректировка области позволяет независимым операциям выполнять параллельно. Но изменение управляемых блокировок требует проверки бизнес-инвариантов: условий, которые должны оставаться истинными при любой последовательности конкурентных операций. Если блокировка защищает остатки, доступность ресурсов или уникальность бизнес-действия, её нельзя сужать только ради уменьшения ожиданий.
Если конкуренцию создаёт регламентное задание, можно ограничить число одновременно выполняемых обработок, изменить размер порций или пересмотреть расписание. Выбор зависит от того, насколько быстро должны обрабатываться данные, каков их объём и какие гарантии нужны при частичном завершении задания. Иногда уменьшение параллелизма снижает количество конфликтов, но одновременно увеличивает длительность обработки. Поэтому нужно оценивать не только deadlock, но и пропускную способность всей системы.
Почему не стоит просто увеличивать тайм-аут
При длительном ожидании блокировки изменение тайм-аута может повлиять на поведение операции. Но при реальном deadlock увеличение времени ожидания не устраняет цикл: PostgreSQL всё равно должен обнаружить взаимоблокировку и отменить одну из транзакций.
Кроме того, большие тайм-ауты могут привести к тому, что пользователи будут дольше ждать завершения операций, не получая никакого улучшения.
Тайм-ауты нужно настраивать в соответствии с требованиями системы, но рассматривать их как средство устранения первопричины неправильно.
Почему увеличение ресурсов тоже может не помочь
Взаимоблокировка связана с порядком доступа к ресурсам, а не обязательно с нехваткой CPU или оперативной памяти.
Если две транзакции образовали цикл, дополнительные вычислительные ресурсы сами по себе не освободят блокировки.
При этом нагрузка влияет на вероятность столкновения: увеличение количества одновременно выполняемых операций способно сделать уже существующий дефект более заметным.
Поэтому масштабирование может изменить частоту проявления проблемы, но не гарантирует её устранения.
Как проверить, что deadlock действительно устранён
Предположим, команда изменила последовательность доступа к данным и сократила продолжительность фоновой транзакции.
Количество жалоб уменьшилось. Можно ли считать инцидент закрытым?
Пока нет.
Для подтверждения результата нужно повторить сценарий, который приводил к проблеме, при сопоставимом уровне конкуренции. Если раньше конфликт возникал при одновременном проведении определённых документов, проверять нужно именно эту комбинацию, а не произвольный набор запросов.
При этом необходимо контролировать несколько показателей:
- количество зарегистрированных deadlock за сопоставимый период;
- продолжительность ожиданий блокировок;
- время выполнения критических операций;
- количество ошибок проведения и повторных попыток;
- длительность фоновых заданий;
- корректность данных после успешного выполнения и отмены операции.
Важно убедиться, что исправление не просто переместило проблему. Например, снижение конфликтов может сопровождаться увеличением времени фоновой обработки или появлением другого узкого места.
Если deadlock возникает редко, одного успешного теста недостаточно. Необходимо наблюдать систему в характерных рабочих условиях и учитывать, что вероятность конфликта зависит от состава операций и времени их выполнения.
Что считать доказательством
Убедительным результатом будет не просто отсутствие ошибок после изменения, а совокупность подтверждений:
- Установлен конкретный механизм исходной взаимоблокировки.
- Изменён участок логики, который создавал конфликтующие последовательности доступа.
- Воспроизведён исходный сценарий при сопоставимой нагрузке.
- Проверено отсутствие исходного цикла в повторных испытаниях и последующем наблюдении.
- Подтверждена корректность бизнес-данных.
- Не ухудшились критические показатели работы системы.
Если после исправления deadlock больше не возникает, но длительность операций существенно выросла, решение нельзя считать однозначно успешным.
Результат должен оцениваться на уровне всей системы, а не одного сообщения об ошибке.
Как сделать так, чтобы следующий инцидент не пришлось расследовать вслепую
Устойчивость к взаимоблокировкам начинается задолго до появления первой жалобы.
В большой информационной системе полезно заранее обеспечить связь между пользовательскими операциями, событиями технологического журнала 1С и журналами PostgreSQL.
Это означает, что при возникновении проблемы инженер должен иметь возможность установить:
- какая операция завершилась ошибкой;
- какие транзакции участвовали в конфликте;
- какие ресурсы оказались взаимно заблокированы;
- какие прикладные действия соответствуют этим транзакциям;
- при каких условиях сценарий повторяется.
Не менее важно контролировать продолжительность транзакций, число ожиданий и характер конкуренции между пользовательскими и фоновыми операциями.
Однако собирать все возможные данные без определённой цели не нужно. Наблюдаемость должна помогать отвечать на конкретные диагностические вопросы, а не создавать бесконечный поток журналов.
Для регулярно повторяющихся операций полезно заранее анализировать потенциально конфликтующие пути выполнения. Если две процедуры изменяют одни и те же наборы данных, стоит проверить, существует ли единый порядок доступа и какие дополнительные операции выполняются внутри транзакций.
Это не гарантирует полного отсутствия deadlock, но позволяет обнаруживать риск до того, как он превратится в регулярный производственный инцидент.
При этом необходимо предусматривать корректную обработку ошибок. Даже хорошо спроектированная система не всегда может полностью исключить взаимоблокировки, поэтому приложение должно безопасно отменять неуспешные транзакции и, где это допустимо, повторять операции с ограничением по количеству попыток.
Задача профилактики — не обещать невозможное отсутствие конфликтов, а сделать их редкими, обнаруживаемыми и безопасными для бизнес-процессов.
Взаимоблокировка — это следствие взаимодействия операций, а не диагноз сервера
Когда пользователи получают ошибки при проведении документов, недостаточно увидеть сообщение о блокировке и изменить несколько настроек PostgreSQL.
Нужно установить, какой механизм проявился: управляемые блокировки 1С, ожидание ресурса в СУБД или настоящий deadlock.
Затем восстановить последовательность событий и определить, какие транзакции удерживали конфликтующие ресурсы.
Журнал PostgreSQL показывает обнаруженный цикл и помогает определить участвующие процессы. Технологический журнал 1С позволяет связать этот цикл с прикладными операциями. Представления pg_stat_activity, pg_blocking_pids() и pg_locks помогают исследовать текущие ожидания и блокирующие связи, когда проблема ещё проявляется.
Но диагностические инструменты не принимают инженерного решения за человека.
После обнаружения конфликта необходимо понять, почему операции обратились к данным в таком порядке, какие требования к целостности ограничивают возможные исправления и как проверить результат при реальной конкуренции.
Иногда решение заключается в унификации порядка доступа к данным. Иногда — в сокращении транзакции, корректировке управляемых блокировок или изменении фоновой обработки. Универсального исправления нет, поскольку одинаковые сообщения об ошибке могут возникать по разным причинам.
Хорошее расследование заканчивается не тогда, когда PostgreSQL перестаёт сообщать о deadlock. Оно заканчивается тогда, когда установлен механизм конфликта, устранена его первопричина, а корректность и производительность системы подтверждены измерениями.
Для большой базы 1С это принципиальная разница между временным снижением количества ошибок и инженерным решением, рассчитанным на дальнейший рост данных, пользователей и нагрузки.
Именно такой подход позволяет поддерживать предсказуемую работу информационной системы: не маскировать симптомы, а понимать, как транзакции взаимодействуют внутри и почему система ведёт себя именно так.
Когда 1С начинает тормозить из-за роста нагрузки
Как подготовить 1С к большому количеству пользователей
Как понять, что серверу не хватает ресурсов
Все инженерные материалы и экспертные статьи
Полный алфавитный справочник ИТ-терминов