If any threads are waiting on this condition then one is selected for waking up. That thread must then re-acquire the lock before returning from {@code await}.
Implementation Considerations
An implementation may (and typically does) require that the current thread hold the lock associated with this {@code Condition} when this method is called. Implementations mustdocument this precondition and any actions taken if the lock is not held. Typically, an exception such as {@link IllegalMonitorStateException} will be thrown.
true if the instance has completed its execution, false otherwise.
An external signal that comes into an execution through one of the {@link ExecutionService#signalExecutionById(String)} methods. It will be delegated to the activity in which the execution is positioned when it receives the external trigger.
The signal method implements how the activity will react on that signal. For example, the outgoing transition could be taken that corresponds with the given signal.
@param execution the {@link Execution} for which the signal is given @param signalName is an abstract text that can be associated with a signal. this corresponds to e.g. a method name in a java class interface. The implementation can decide e.g. to use the signal to identify the outgoing transition. @param parameters is extra information that can be provided with a signal.In this way, it is somewhat similar to the parameters that can be fed into a method invocation through reflection. @throws Exception to indicate any kind of failure. Note that exceptions are considered non recoverable. After an Exception, the execution should not be used any more and if this is during a transaction, the transaction should be rolled back.Typically a signal causes the execution to proceed, but that doesn't necesserily has to be the case . The {@link ExternalActivity} is responsible for interpreting the signal and acting upon it.
A signal can optionally be given {@link #signal(String) a signal name}, {@link #signal(Map) a map of parameters} or {@link #signal(String,Map) both}.
Since it's an external trigger, this method requires that this execution is waiting for an external trigger. So this method must be called as an external client and can not be called while this execution is executing. In an {@link Activity} for example you're not allowed to call the signal on the execution cause it is executing. But you are allowed to invoke this method on any other execution (at least, if that one is waiting for an external trigger).
Typically a signal will cause the execution to start executing, but that is not a must. What happens with this signal is defined in the {@link ExternalActivity#signal(Execution,String,Map)} of the {@link #getNode() current node}.
@see #signal(String)An external trigger that comes into an execution through one of the {@link Execution#signal()} methods, will be delegated to the node in which the execution is positioned when it receives the external trigger.
The signal method implements how the node will react on that signal. For example, the outgoing transition could be taken that corresponds with the given signal.
@param execution the {@link Execution} for which the signal is given @param signalName is an abstract text that can be associated with a signal. this corresponds to e.g. a method name in a java class interface. The implementation can decide e.g. to use the signal to identify the outgoing transition. @param parameters is extra information that can be provided with a signal.In this way, it is somewhat similar to the parameters that can be fed into a method invocation through reflection. @throws Exception to indicate any kind of failure. Note that exceptions are considered non recoverable. After an Exception, the execution should not be used any more and if this is during a transaction, the transaction should be rolled back.Typically a signal causes the execution to proceed, but that doesn't necessarily has to be the case . The {@link ExternalActivityBehaviour} is responsible for interpreting the signal and acting upon it.
A signal can optionally be given {@link #signal(String) a signal name}, {@link #signal(Map) a map of parameters} or {@link #signal(String,Map) both}.
Since it's an external trigger, this method requires that this execution is waiting for an external trigger. So this method must be called as an external client and can not be called while this execution is executing. In an {@link ActivityBehaviour} for example you're not allowed to call the signal on the execution cause it is executing. But you are allowed to invoke this method on any other execution (at least, if that one is waiting for an external trigger).
Typically a signal will cause the execution to start executing, but that is not a must. What happens with this signal is defined in the {@link ExternalActivityBehaviour#signal(Execution,String,Map)} of the current activity.
@see #signal(String) | |
| |
| |
| |
| |
| |
| |
| |
| |
| |