What causes "Not supported to signal this execution" in flowable/flowable-engine?

Signal the correct child/inner execution (the one inside the multi-instance scope), not the multi-instance root execution.

flowable/flowable-engine · error · FlowableException

Not supported to signal this execution

Error message

Not supported to signal this execution

What it means

MultiInstanceActivityBehavior.signal intercepts signals intended for a multi-instance execution and, when the wrapped inner behavior is an AbstractBpmnActivityBehavior (i.e. the signal targets the multi-instance scope itself rather than an inner activity that supports signaling), it throws this FlowableException because signaling the multi-instance wrapper is not supported.

Source

Thrown at modules/flowable5-engine/src/main/java/org/activiti/engine/impl/bpmn/behavior/MultiInstanceActivityBehavior.java:109

            } catch (BpmnError error) {
                ErrorPropagation.propagateError(error, activityExecution);
            }

            if (resolveNrOfInstances(activityExecution) == 0) {
                leave(activityExecution);
            }
        } else {
            innerActivityBehavior.execute(execution);
        }
    }

    protected abstract void createInstances(ActivityExecution execution);

    // Intercepts signals, and delegates it to the wrapped {@link ActivityBehavior}.
    @Override
    public void signal(ActivityExecution execution, String signalName, Object signalData) throws Exception {
        if (innerActivityBehavior instanceof org.flowable.engine.impl.bpmn.behavior.AbstractBpmnActivityBehavior) {
            throw new FlowableException("Not supported to signal this execution");
        } else {
            ((AbstractBpmnActivityBehavior) this.innerActivityBehavior).signal(execution, signalName, signalData);
        }
    }

    // required for supporting embedded subprocesses
    @Override
    public void lastExecutionEnded(ActivityExecution execution) {
        ScopeUtil.createEventScopeExecution((ExecutionEntity) execution);
        leave(execution);
    }

    // required for supporting external subprocesses
    @Override
    public void completing(DelegateExecution execution, DelegateExecution subProcessInstance) throws Exception {
    }

    // required for supporting external subprocesses

View on GitHub (pinned to d6d39ce1c6)

Solutions

Signal the correct child/inner execution (the one inside the multi-instance scope), not the multi-instance root execution.
Inspect the execution tree (runtimeService.createExecutionQuery().processInstanceId(...)) and target the active child execution of the multi-instance activity.
If you need to cancel or advance the whole multi-instance block, use process-instance modification (changeActivityState) or deletion of the execution instead of signal().
Check that the inner activity type actually supports signaling; non-waiting inner behaviors have nothing to signal.

Example fix

// before: signals the multi-instance root
Execution miRoot = executionQuery.list().get(0);
runtimeService.signal(miRoot.getId());

// after: signal the active child execution inside the scope
Execution inner = runtimeService.createExecutionQuery()
    .processInstanceId(processInstanceId)
    .activityId("innerReceiveTask")
    .singleExecution();
runtimeService.signal(inner.getId());

Defensive patterns

Strategy: type-guard

Validate before calling

// Guard before signaling: only signal executions whose current activity is not the multi-instance wrapper
boolean isSignable = runtimeService.createExecutionQuery()
    .executionId(executionId)
    .activityId(innerActivityId)
    .singleResult() != null;
if (!isSignable) throw new IllegalStateException("Target the inner child execution, not the multi-instance root");

Type guard

// Narrow to a child execution of the multi-instance scope
Execution findInnerExecution(String processInstanceId, String innerActivityId) {
    return runtimeService.createExecutionQuery()
        .processInstanceId(processInstanceId)
        .activityId(innerActivityId)
        .singleResult();
}

Try / catch

try {
    runtimeService.signal(executionId);
} catch (org.flowable.engine.FlowableException e) {
    if ("Not supported to signal this execution".equals(e.getMessage())) {
        // look up the child execution inside the multi-instance scope and signal that instead
    } else {
        throw e;
    }
}

Prevention

Never signal the miRoot/parent execution of a multi-instance block; always resolve the active child execution.
Use execution queries filtered by activityId to find the correct signaling target.
For advancing/cancelling whole multi-instance scopes, use runtimeService.createChangeActivityStateBuilder() instead of signal().
Be careful with custom execution-tree walking code after process restarts or async continuations.

When it happens

Trigger: Calling execution.signal(signalName, signalData) (or task completion / event triggering routed to the execution) on the execution whose behavior is a MultiInstanceActivityBehavior wrapping an AbstractBpmnActivityBehavior.

Common situations: Signaling a receive-task-like activity inside a multi-instance block but resolving to the wrong (parent multi-instance) execution; custom code walking the execution tree and signaling the miRoot execution; process-correlation code that signals executions by id after restarts.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

AI-assisted analysis of flowable/flowable-engine@d6d39ce1c6 (2026-09-11). Data as JSON: /api/errors/049c6a61fa8981ba. Report an issue: GitHub.