Транзакции в процессах

Процессный движок представляет собой пассивный Java-код, который выполняется в потоке клиента. Например, если веб-приложение позволяет пользователям запускать новый экземпляр процесса и пользователь нажимает соответствующую кнопку, то поток из пула HTTP-потоков сервера приложений вызывает метод API runtimeService.startProcessInstanceByKey(…​), входит в процессный движок и запускает новый экземпляр процесса. Это называется «заимствованием потока клиента» (borrowing the client thread).

При любом внешнем триггере (запуске процесса, завершении задачи, сигнале выполнению) движок продвигает процесс, пока на каждом активном пути выполнения не будет достигнуто состояние ожидания (wait state). Состояние ожидания означает задачу, которая выполняется позже: движок сохраняет текущее выполнение в базе данных и ждёт следующего триггера. Например, для пользовательской задачи внешний триггер «завершение задачи» заставляет движок выполнить следующую часть процесса, пока снова не будут достигнуты состояния ожидания (или пока экземпляр не завершится). Событие таймера, в отличие от пользовательской задачи, не запускается извне. Его продолжает внутренний триггер. Поэтому движку нужен и активный компонент, исполнитель заданий (Job Executor), который забирает зарегистрированные задания и обрабатывает их асинхронно.

Состояния ожидания

Состояния ожидания служат границами транзакций: в них состояние процесса сохраняется в базе данных, поток возвращается клиенту, а транзакция фиксируется (commit). Следующие элементы BPMN всегда являются состояниями ожидания:

Задача получения

Пользовательская задача

Событие сообщения

Событие таймера

Событие сигнала

Событийный шлюз

Сервисная задача

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

Границы транзакций

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

Границы транзакций

На рисунке фрагмент BPMN-процесса с пользовательской задачей, сервисной задачей и событием таймера. Событие таймера обозначает следующее состояние ожидания. Значит, завершение пользовательской задачи и проверка адреса входят в одну единицу работы (unit of work), то есть должны атомарно завершиться успешно или неуспешно. Если сервисная задача выбрасывает исключение, текущая транзакция должна откатиться, чтобы выполнение вернулось к пользовательской задаче и пользовательская задача по-прежнему оставалась в базе данных. Так процессный движок и ведёт себя по умолчанию.

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

Асинхронные продолжения

Зачем нужны асинхронные продолжения

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

Асинхронные продолжения

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

Настройка асинхронных продолжений

Асинхронные продолжения можно задать до и после активити. Кроме того, асинхронно можно запустить и сам экземпляр процесса.

Асинхронное продолжение до активити включается атрибутом расширения camunda:asyncBefore:

<serviceTask id="service1" name="Generate Invoice" camunda:asyncBefore="true" camunda:class="my.custom.Delegate" />

Асинхронное продолжение после активити включается атрибутом расширения camunda:asyncAfter:

<serviceTask id="service1" name="Generate Invoice" camunda:asyncAfter="true" camunda:class="my.custom.Delegate" />

Асинхронный запуск экземпляра процесса включается атрибутом расширения camunda:asyncBefore на стартовом событии уровня процесса. При запуске экземпляр процесса создаётся и сохраняется в базе данных, но его выполнение откладывается. Слушатели выполнения при этом тоже не вызываются синхронно. Это полезно в разных ситуациях, например в гетерогенных кластерах, когда класс слушателя выполнения недоступен на узле, который запускает экземпляр процесса.

<startEvent id="theStart" name="Invoice Received" camunda:asyncBefore="true" />

Асинхронные продолжения для активити с множественными экземплярами

Активити с множественными экземплярами можно настроить на асинхронное продолжение так же, как и другие активити. Асинхронное продолжение, объявленное для такой активити, делает асинхронным тело множественного экземпляра (multi-instance body): процесс продолжится асинхронно до создания экземпляров активити или после завершения всех экземпляров.

Кроме того, асинхронное продолжение можно задать и для внутренней активити атрибутами расширения camunda:asyncBefore и camunda:asyncAfter элемента multiInstanceLoopCharacteristics:

<serviceTask id="service1" name="Generate Invoice" camunda:class="my.custom.Delegate">
	<multiInstanceLoopCharacteristics isSequential="false" camunda:asyncBefore="true">
 		<loopCardinality>5</loopCardinality>
	</multiInstanceLoopCharacteristics>
</serviceTask>

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

Как работают асинхронные продолжения

Чтобы понять, как работают асинхронные продолжения, сначала разберём, как выполняется активити:

Выполнение активити

На рисунке показано, как выполняется обычная активити, в которую процесс входит по потоку управления и выходит по потоку управления:

  1. Вызываются слушатели TAKE входящего потока управления.

  2. Вызываются слушатели START самой активити.

  3. Выполняется поведение активити, которое зависит от её типа: для сервисной задачи (Service Task) это вызов кода делегирования, для пользовательской задачи (User Task) создание экземпляра Task в списке задач и т. п.

  4. Вызываются слушатели END активити.

  5. Вызываются слушатели TAKE исходящего потока управления.

Асинхронные продолжения позволяют вставить точки разрыва между выполнением потока управления и выполнением активити:

Точки разрыва асинхронных продолжений

На рисунке показано, где разные типы асинхронных продолжений разрывают выполнение:

  • Асинхронное продолжение ДО активити разрывает выполнение между вызовом слушателей TAKE входящего потока управления и слушателей START активити.

  • Асинхронное продолжение ПОСЛЕ активити разрывает выполнение между вызовом слушателей END активити и слушателей TAKE исходящего потока управления.

Асинхронные продолжения напрямую связаны с границами транзакций: асинхронное продолжение до или после активити создаёт границу транзакции до или после активити:

Асинхронные продолжения и границы транзакций

Асинхронные продолжения всегда выполняет исполнитель заданий.

Откат при исключении

При необработанном исключении текущая транзакция откатывается, и экземпляр процесса остаётся в последнем состоянии ожидания (точке сохранения). Это показано на следующем рисунке.

Откат транзакции

Если исключение возникло при вызове startProcessInstanceByKey, экземпляр процесса вообще не сохраняется в базе данных.

Почему выбран такой подход

Такое поведение часто вызывает вопросы: от процессного движка ожидают, что он остановится на задаче, которая вызвала исключение. К тому же другие BPM-системы часто делают каждую задачу состоянием ожидания. Однако у выбранного подхода есть преимущества:

  • В тестах точно известно состояние движка после вызова метода, поэтому проще проверять состояние процесса или результаты вызовов сервисов.

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

  • Выполнение сводится к обычным вычислениям на Java, а это очень производительно.

  • Если нужно другое поведение, всегда можно включить asyncBefore/asyncAfter=true.

Но есть и последствия, которые нужно учитывать:

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

  • Параллельные пути процесса не выполняются параллельно в смысле потоков Java: пути выполняются последовательно, так как используется только один поток.

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

Таймер

Интеграция транзакций

Процессный движок может либо сам управлять транзакциями (автономное управление транзакциями), либо интегрироваться с менеджером транзакций платформы.

Автономное управление транзакциями

При автономном управлении транзакциями процессный движок всегда открывает новую транзакцию для каждой выполняемой команды. Чтобы настроить процессный движок на автономное управление транзакциями, используйте io.openbpm.bpm.engine.impl.cfg.StandaloneProcessEngineConfiguration:

ProcessEngineConfiguration.createStandaloneProcessEngineConfiguration()
  ...
  .buildProcessEngine();

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

В дистрибутиве Tomcat процессный движок настроен на автономное управление транзакциями.

Интеграция с менеджером транзакций

Процессный движок можно интегрировать с менеджером транзакций. Из коробки поддерживается интеграция со Spring и JTA. Подробнее см.:

Интеграция с менеджером транзакций нужна, когда процессный движок работает вместе с:

  • моделями программирования, ориентированными на транзакции, такими как Jakarta EE или Spring (например, JPA EntityManager с областью действия транзакции в Jakarta EE);

  • другими транзакционными ресурсами, такими как дополнительные источники данных, системы обмена сообщениями или другое транзакционное промежуточное ПО, например стек веб-сервисов.

Настраивая менеджер транзакций, убедитесь, что он действительно управляет источником данных, который настроен для процессного движка. Иначе источник данных работает в режиме auto-commit. Это может привести к несогласованности данных в базе, потому что фиксация и откат транзакций больше не выполняются.

Транзакции и контекст процессного движка

Когда выполняется команда процессного движка (Process Engine Command), движок создаёт контекст процессного движка (Process Engine Context). Контекст кеширует сущности базы данных, поэтому повторные операции с одной сущностью не приводят к повторным запросам к базе данных. Изменения этих сущностей накапливаются и сбрасываются (flush) в базу данных, как только команда возвращает управление. При этом текущая транзакция может быть зафиксирована позже.

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

Если вложенную команду нужно выполнить в новой транзакции, для неё нужно создать новый контекст процессного движка. Тогда вложенная команда использует новый кеш сущностей базы данных, независимый от кеша внешней команды. Изменения в кеше одной команды не видны другой, и наоборот. Когда вложенная команда возвращает управление, её изменения сбрасываются в базу данных независимо от контекста процессного движка внешней команды.

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

try {

  // объявить новый контекст процессного движка
  ProcessEngineContext.requiresNew();

  // вызвать API движка
  execution.getProcessEngineServices()
    .getRuntimeService()
    .startProcessInstanceByKey("EXAMPLE_PROCESS");

} finally {
  // снять объявление нового контекста процессного движка
  ProcessEngineContext.clear();
}

Оптимистическая блокировка

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

Чтобы обнаруживать и разрешать такие ситуации, OpenBPM Engine использует известную технику оптимистической блокировки (optimistic locking, или optimistic concurrency control).

Раздел состоит из двух частей. Первая объясняет оптимистическую блокировку как понятие, её можно пропустить, если оно вам знакомо. Вторая описывает, как оптимистическая блокировка используется в OpenBPM Engine.

Что такое оптимистическая блокировка

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

Пример

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

Id Version Name Address …​

8

1

Steve

3, Workflow Boulevard, Token Town

…​

…​

…​

…​

…​

…​

В таблице одна строка с данными пользователя. У пользователя есть уникальный идентификатор (первичный ключ), версия, имя и текущий адрес.

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

Транзакции с оптимистической блокировкой

На рисунке Transaction 1 читает данные пользователя, что-то с ними делает, удаляет пользователя и фиксирует транзакцию. Transaction 2 начинается одновременно с ней, читает те же данные пользователя и тоже с ними работает. Когда Transaction 2 пытается обновить адрес пользователя, обнаруживается конфликт (Transaction 1 уже удалила пользователя).

Конфликт обнаруживается потому, что текущее состояние данных пользователя читается в момент обновления в Transaction 2. К этому моменту параллельная Transaction 1 уже пометила строку на удаление. База данных ждёт завершения Transaction 1, после чего Transaction 2 может продолжить. Строки к этому моменту уже нет, поэтому обновление выполняется, но сообщает, что изменено 0 строк. Приложение может отреагировать на это и откатить Transaction 2, чтобы другие изменения этой транзакции не применились.

Затем приложение (или его пользователь) решает, нужно ли повторить Transaction 2. В нашем примере повторная транзакция не найдёт данных пользователя и сообщит, что пользователь удалён.

Оптимистическая и пессимистическая блокировка

Пессимистическая блокировка работает с блокировками чтения. Блокировка чтения закрывает объект данных при чтении, и другие параллельные транзакции не могут его прочитать. Так конфликты предотвращаются заранее.

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

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

Однако пессимистические блокировки монопольны, поэтому снижают параллелизм и производительность. Поэтому при высоком уровне параллелизма и преобладании чтения над записью предпочтительна оптимистическая блокировка, которая обнаруживает конфликты, а не предотвращает их. Кроме того, пессимистическая блокировка легко приводит к взаимоблокировкам (deadlocks).

Оптимистическая блокировка в OpenBPM Engine

OpenBPM Engine управляет параллельным доступом с помощью оптимистической блокировки. При обнаружении конфликта выбрасывается исключение и транзакция откатывается. Конфликты обнаруживаются при выполнении операторов UPDATE и DELETE. Операторы UPDATE и DELETE возвращают число затронутых строк. Если оно равно нулю, значит, строку уже обновили или удалили. В этом случае конфликт считается обнаруженным и выбрасывается OptimisticLockingException.

Исключение OptimisticLockingException

OptimisticLockingException могут выбрасывать методы API. Рассмотрим вызов метода complete(…​):

taskService.complete(aTaskId); // может выбросить OptimisticLockingException

Этот метод может выбросить OptimisticLockingException, если при его выполнении данные изменяются параллельно.

Выполнение задания тоже может привести к OptimisticLockingException. Это ожидаемое поведение, поэтому выполнение будет повторено.

Обработка исключений оптимистической блокировки

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

Если текущая команда запущена внешним вызовом API, OpenBPM Engine откатывает текущую транзакцию к последней точке сохранения (состоянию ожидания). Дальше пользователь решает, как обработать исключение: повторять транзакцию или нет. Учтите, что даже откаченная транзакция могла иметь нетранзакционные побочные эффекты, которые не откатываются.

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

Где обычно возникают исключения оптимистической блокировки

OptimisticLockingException обычно возникает в следующих местах:

  • Конкурирующие внешние запросы: одна и та же задача одновременно завершается дважды.

  • Точки синхронизации внутри процесса: параллельный шлюз, множественный экземпляр и т. п.

В следующей модели OptimisticLockingException может возникнуть на параллельном шлюзе.

Оптимистическая блокировка на параллельном шлюзе

После разветвляющего параллельного шлюза идут две пользовательские задачи. Объединяющий параллельный шлюз после них сливает выполнения в одно. Чаще всего одна из пользовательских задач завершается первой. Тогда выполнение ждёт на объединяющем параллельном шлюзе завершения второй пользовательской задачи.

Однако обе пользовательские задачи могут завершиться одновременно. Допустим, завершена верхняя задача. Её транзакция считает, что пришла на объединяющий параллельный шлюз первой. Нижняя задача завершается параллельно, и её транзакция тоже считает, что пришла первой. Обе транзакции пытаются обновить строку, которая отмечает первое прибытие на объединяющий параллельный шлюз. В этом случае выбрасывается OptimisticLockingException: одна транзакция откатывается, другая успешно обновляет строку.

Оптимистическая блокировка и нетранзакционные побочные эффекты

После OptimisticLockingException транзакция откатывается, и вся транзакционная работа отменяется. Нетранзакционная работа, например созданные файлы или результаты вызова нетранзакционных веб-сервисов, не отменяется. Это может привести к несогласованному состоянию.

У этой проблемы несколько решений. Самое распространённое: согласование в конечном счёте (eventual consolidation) с помощью повторных попыток.

Внутреннее устройство

Большинство таблиц базы данных OpenBPM Engine содержат столбец REV_ с номером ревизии. Строка всегда читается в определённой ревизии. Изменения (UPDATE и DELETE) всегда обновляют ту ревизию, которую прочитала текущая команда, а обновление увеличивает номер ревизии. После выполнения изменяющего оператора проверяется число затронутых строк. Если оно равно 1, прочитанная версия ещё была актуальной в момент изменения. Если оно равно 0, другая транзакция изменила те же данные, пока выполнялась текущая. Это конфликт параллельного доступа, и фиксировать эту транзакцию нельзя. Поэтому транзакция откатывается (или помечается как rollback-only) и выбрасывается OptimisticLockingException.

Документация создана на основе Camunda 7 Docs (Camunda, docs.camunda.org) и распространяется по лицензии Creative Commons Attribution-ShareAlike 3.0 Unported.