5.0 Advanced Behavioral Modeling: 5.1 Events and signals, 5.2 State machines, 5.

3 Processes
and Threads, 5.4 Time and space, 5.5 State chart diagrams.
5.0 Advanced Behavioral Modeling:
5.1 Events and Signals
Introduction:
In state machines (sequence of states), we use events to model the occurrence of a stimulus that
can trigger an object to move from one state to another state. Events may include signals, calls,
and the passage of time or a change in state.
In UML, each thing that happens is modeled as an event. An event is the specification of a
significant occurrence that has a location in time and space. A signal, passing of time and change
in state are asynchronous events. Calls are generally synchronous events, representing invocation
of an operation.
UML allows us to represent events graphically as shown below. Signals may be represented as
stereotyped classes and other events are represented as messages associated with transitions
which cause an object to move from one state to another.

Types of Events:
Events may be external or internal. Events passed between the system and its actors are external
events. For example, in an ATM system, pushing a button or inserting a card are external events.
Internal events are those that are passed among objects living inside the system. For example, a
overflow exception generated by an object is an internal event.
In UML, we can model four kinds of events namely: signals, calls, passing of time and change in
state.
Signals:
A signal is a named object that is sent asynchronously by one object and then received by
another. Exceptions are the famous examples for signals. A signal may be sent as the action of a
state in a state machine or as a message in an interaction. The execution of an operation can also
send signals. In UML, we model the relationship between an operation and the events using a
dependency stereotyped with “send”, which indicates that an operation sends a particular signal.
Call Events:
A call event represents the dispatch of an operation from one object to another. A call event may
trigger a state change in a state machine. A call event, in general, is synchronous. This means
that the sender object must wait until it gets an acknowledgment from the receiver object which
receives the call event. For example, consider the states of a customer in an ATM application:

Time and Change Events:

A time event represents the passage of time. In UML, we model the time event using the “after”
keyword followed by an expression that evaluates a period of time.
A change event represents an event that represents a change in state or the satisfaction of some
condition. In UML, change event is modeled using the keyword “when” followed by some
Boolean expression.

Sending and Receiving Events:

Any instance of a class can receive a call event or signal. If this is a synchronous call event, the
sender is in locked state with receiver. If this is a signal, then the sender is free to carry its
operations without any concern on the receiver.
In UML, call events are modeled as operations on the class of an object and signals that an object
can receive are stored in an extra component in the class as shown below:

Common Modeling Techniques:

Modeling a family of signals:
To model a family of signals,
1. Consider all the signals to which a set of objects can respond.
2. Arrange these signals in a hierarchy using generalization-specialization relationship.
3. Look out for polymorphism in the state machine of the active objects. When
polymorphism is found, adjust the hierarchy by introducing intermediate abstract signals.

Modeling Exceptions:
To model exceptions,
1. For each class and interface and for each operation of such elements, consider the
exceptional conditions that might arise.
2. Arrange these exceptions in a hierarchy.
3. For each operation, specify the exceptions that it may rise.
5.2 State Machines
Introduction:
A state machine is a behavior that represents the sequences of states that an object undergoes
during its lifetime in response to events, together with its responses to those events.
The state of an object is a condition or situation during the life of an object during which it
satisfies some condition, performs some activity or waits for some event.
We can visualize a state machine in two ways: 1) by focusing on the control flow from one
activity to another (using activity diagrams) or 2) by focusing on the states of objects and the
transitions among those states (using state chart diagrams).

States:
A state is a condition or situation during the life of an object during which it satisfies some
condition, performs some activity, or waits for some event. An object remains in a state for a
finite amount of time. A state has several parts:
 Name A textual string which distinguishes one state from other states
Entry/exit actions Actions executed on entering and exiting the state
Internal transitions Transitions that are handled without causing a change in state
Substates The nested structure of a state, involving disjoint or concurrent
substates
Deferred events A list of events that are not handled in that state, but are postponed or
queued for handling by the object in another state

A state is represented as a rectangle with rounded corners as shown below:

Initial and Final States:

As we can see from the above figure, there are two special states that may be defined for an
object‟s state machine. First, the initial state, which indicates the default starting place of control
for the state machine or sub state. Initial state is represented as a filled black circle. Second, the
final state, which indicates that the execution of the state machine or the enclosing state has been
completed. Final state is represented as filled black circle enclosed in a hollow circle.
Transitions:
A transition is a relationship between two states indicating that an object in one state will
perform certain actions and enter another state when a specified event occurs and specified
conditions are satisfied. A transition has five parts:
Source state The state affected by the transition
Event trigger The event whose reception changes the state of the object
Guard condition A boolean expression which is evaluated when the transition is
triggered
Action An executable atomic computation that is performed on or by an object
Target state The state that is active after the completion of the transition

A transition is visually represented as a solid directed line from the source state to the target
state. A self-transition is a transition whose source and target states are the same.
Event Trigger:
An event is a specification of a significant occurrence that has location in time and space. In state
machines, an event is an occurrence of stimulus that can trigger a state transition. For example,
the “play button” makes the music player to change from “idle” state to “playing”.
There can be triggerless transitions which are represented by a transition with no event trigger. A
triggerless transition also called a completion transition is triggered implicitly when its source
state has completed its activity.
Guard Condition:
A guard condition is rendered as a Boolean expression enclosed in square brackets and placed
after the trigger event. A guard condition is evaluated only after the trigger event for its transition
occurs. Therefore, it‟s possible to have multiple transitions from the same source state and with
the same event trigger, as long as those conditions don‟t overlap.
Action:
An action is an executable atomic computation. Actions may be method calls, signals or creation
of objects or destruction of objects.
Advanced States and Transitions:
UML‟s state machines provide a number of advanced features that help us to manage complex
behavioral models. Some of these advanced features include entry and exit actions, internal
transitions, activities and deferred events.
Entry and Exit Actions:
When the control enters a certain state, it might carry out a particular action. Such action is
known as an entry action. Similarly, a state might carry out a particular action when the control
leaves that state. Such action is known as exit action. Entry and exit actions are represented using
the keywords “entry” and “exit” respectively.
Internal Transitions:
In state machines, a state might process certain events without leaving the current state. Such
transitions which represent events that are handled without leaving the current state are known as
internal transitions. Internal transitions are different from self transitions in the sense that events
on self transitions are handled outside the current state.
Activities:
After entering the state, that state might do a set of actions. These actions are collectively known
as the activity performed by a state. In UML, activities are represented using the keyword “do”.
Deferred Events:
In some situations, a state might handle certain events in another state of the object. Such events
which are postponed to be handled later in another state are known as deferred events. In UML,
deferred events are represented with the “do” action.
Substates
A substate is a state included in another state. In UML, we render a composite state just like a
normal state, but with an optional graphic compartment that shows a nested state machine.
Substates may be nested to any level.
Sequential Substates:
Consider the state machine for ATM system:
Substates such as Validating and Processing are called sequential or disjoint substates. Given a
set of disjoint states in an enclosing composite state, the object is said to be in the composite
state and in only one of the disjoint substates at a time. Therefore, sequential substates divide the
state space of the composite state into disjoint states. A nested sequential state machine may have
at most one initial state and one final state.
History States:
Unless otherwise specified, when a transition enters a composite state, the action of the nested
state machine starts over again at its initial state. However, there are situations in which we
might want the state machine to remember the last substate that was active prior to leaving the
composite state.
For example, in modeling the behavior of an agent which performs unattended backup of
computers across the network, we like it to remember where it was in the process if it ever gets
interrupted by, for example, a query from the operator.
A history state allows a composite state that contains sequential substates to remember the last
substate that was active in it prior to the transition from the composite state. In UML, a history is
represented as a hollow circle with the symbol „H‟ as shown in the below figure:
Concurrent Substates:
Concurrent substates allow us to specify two or more state machines that execute in parallel in
the context of the enclosing object.
For example, in the below figure, the Maintenance mode is decomposed into two concurrent
substates, Testing and Commanding, shown by nesting them in the Maintenance state but
separating them from one another with a dashed line. Each of these concurrent substates is
further divided into sequential substates.
Execution of these two concurrent substates continues in parallel. Eventually, each nested state
machine reaches its final state. If one concurrent substate reaches its final state before the other,
control in that substate waits at its final state. When both the nested state machines reach their
final state, control from the two concurrent substates joins back into one flow.

Common Modeling Techniques:

Modeling the Lifetime of an Object:
To model the lifetime of an object:
 Set the context for the state machine, whether it is a class, whether it is a class, a use case,
or the system as a whole.
 Establish the initial and final states for the object.
 Consider the events to which this object may respond.
 Starting from the initial state to the final state, lay out the top level states the object may
be in. Connect these states with transitions triggered by the appropriate events.
 Identify any entry or exit actions.
 Expand these states as necessary by using substates.
  Check for the consistency of events in the object interface with the events in the state
machine.
 Check that all actions mentioned in the state machine are sustained by the relationships,
methods and operations of the enclosing object.
 Trace through the state machine, either manually or by using tools, to check it against
expected sequences of events and their responses.
 After rearranging, again check it against the expected sequences to ensure that you have
not changed the object‟s semantics.

5.3 Processes and Threads

In the UML, each independent flow of control is modeled as an active object. An active object is
a process or thread that can initiate control activity.
A process is a heavyweight flow that can execute concurrently with other processes.
A thread is a lightweight flow that can execute concurrently with other threads within the same
process.
An active object is an object that owns a process or thread and can initiate control activity.
An active class is a class whose instances are active objects.
Graphically, an active class is rendered as a rectangle with thick lines. Processes and threads are
rendered as stereotyped active classes.

Figure 5.3.1 Active Class

Flow of Control
There are two types of flow of control sequential system, concurrent system.
In a sequential system, there is a single flow of control. i.e, one thing, and one thing only, can
take place at a time.
In a concurrent system, there is multiple simultaneous flow of control i.e, more than one thing
can take place at a time.
Classes and Events
Active classes are just classes which represents an independent flow of control. Active classes
share the same properties as all other classes. When an active object is created, the associated
flow of control is started; when the active object is destroyed, the associated flow of control is
terminated.
Communication
In a system with both active and passive objects, there are four possible combinations of
interaction
First, a message may be passed from one passive object to another.
Second, a message may be passed from one active object to another. When that happens, you
have inter-process communication, and there are two possible styles of communication.
In inter-process communication there are two possible styles of communication. First, one
active object might synchronously call an operation of another. Second, one active object might
asynchronously send a signal or call an operation of another object a synchronous message is
rendered as a full arrow and an asynchronous message is rendered as a half arrow.

Figure 5.3.2: Communication

Third, a message may be passed from an active object to a passive object
Fourth, a message may be passed from a passive object to an active one
Synchronization
Synchronization means arranging the flow of controls of objects so that mutual exclusion will be
guaranteed. In object-oriented systems these objects are treated as a critical region.
The key to this problem is serialization of access to the critical object. There are three
approaches, each of which involves attaching certain synchronization properties to the operations
defined in a class. In the UML, you can model all three approaches.
1. Sequential Callers must coordinate outside the object so that only one flow is in the object
at a time. In the presence of multiple flows of control, the semantics and
integrity of the object cannot be guaranteed.
2. Guarded The semantics and integrity of the object is guaranteed in the presence of
multiple flows of control by sequentializing all calls to all of the object's
guarded operations. In effect, exactly one operation at a time can be invoked on
the object, reducing this to sequential semantics.
3. Concurrent The semantics and integrity of the object is guaranteed in the presence of
multiple flows of control by treating the operation as atomic

Figure 5.3.3 Synchronization

Common Modeling Techniques
Modeling Multiple Flows of Control
To model multiple flows of control,
 Identify the opportunities for concurrent execution and reify each flow as an active class.
 Consider a balanced distribution of responsibilities among these active classes, and then
examine the other active and passive classes with which each collaborates statically.
 Capture these static decisions in class diagrams, explicitly highlighting each active class.
 Consider how each group of classes collaborates with one another dynamically.
 Pay close attention to communication among active objects. Apply synchronous and
asynchronous messaging, as appropriate.
 Pay close attention to synchronization among these active objects and the passive objects
with which they collaborate.
For example, Figure 5.4 shows part of the process view of a trading system. You'll find three
objects that push information into the system concurrently: a StockTicker, an IndexWatcher, and
a CNNNewsFeed (named s, i, and c, respectively). Two of these objects (s and i) communicate
with their own Analyst instances (a1 and a2). At least as far as this model goes, the Analyst can
be designed under the simplifying assumption that only one flow of control will be active in its
instances at a time. Both Analyst instances, however, communicate simultaneously with an
AlertManager (named m). Therefore, m must be designed to preserve its semantics in the
presence of multiple flows. Both m and c communicate simultaneously with t, a
TradingManager.

Figure 5.3.4 Modeling Flows of Control

Modeling Inter-process Communication
To model inter-process communication,
 Model the multiple flows of control.
 Model messaging using asynchronous communication; model remote procedure calls
using synchronous communication.
 Informally specify the underlying mechanism for communication by using notes, or more
formally by using collaborations.
Figure 5.5 shows a distributed reservation system with processes spread across four nodes. Each
object is marked using the process stereotype. Each object is also marked with a location tagged
value, specifying its physical location. Communication among the ReservationAgent,
TicketingManager, and HotelAgent is asynchronous. Modeled with a note, communication is
described as building on a Java Beans messaging service. Communication between the
TripPlanner and the ReservationSystem is synchronous. The semantics of their interaction is
found in the collaboration named CORBA ORB. The TripPlanner acts as a client, and the
ReservationAgent acts as a server. By zooming into the collaboration, you'll find the details of
how this server and client collaborate.

Figure 5.3.5 Modeling Inter-process Communication

5.4 Time and space
Real time and distributed systems require the ability to model time and space. The UML
provides the ability to visualize, specify, construct, and document these types of systems using
timing marks, time expressions, constraints, and tagged values.
A real time system is one that requires a certain behavior to be carried out at a precise time, and
for a specific duration.
A distributed system is one that requires the ability to physically distribute components
(discussed in chap 25) across nodes. A node may mean different processors physically located on
the same box or in different locations.
The UML elements used to meet the modeling requirements of real time and distributed systems
include:
 Timing marks
 Time expressions
 Timing constraints
 Location

Figure 5.4.1 Timing Constraints and Location

A timing mark shows the instant in time, relative to the interaction, at which an event occurs.
Graphically, a timing mark is just an expression using the name given to the message such as 'a'
or 'b' in the example.
A time expression is an expression evaluates to a relative or absolute value of time.
A timing constraint is a semantic statement about the relative or absolute value of time. (Like
other constraints, are generally connected to an element using a dependency relationship.)
Location refers to the placement of a component on a node, and is given as a tagged value.
Time
Real time systems are by definition, time-critical systems. This means that events, and responses
to events occur at regular or irregular times that are predictable. To represent time, each message
that is used in an interaction can be identified by name, to be used as a timing mark. This is what
we mean when we say a timing mark is nothing more than an expression formed from the name
of message in an interaction. Given the message name then, you can refer to three functions of
the message:
1. StartTime
2. StopTime
3. ExecutionTime
In fig 5.4.2, you see that you can use expressions containing these functions (executionTime in
the example) to specify the timing behavior of the system. You should also recognize fig 5.4.2 is
a collaboration diagram that we have added timing constraints to.

Figure 5.4.2 Time

Location
The most important three things to remember in real estate are location, location, location.
Distributed systems, by their nature, are made up of components that are physically spread across
different processors (referred to as nodes) in a system. In web based systems using Java Applets,
it is also possible for components to migrate from node to node. This is in fact, the genesis of the
NC (network computer).
In the UML, you model the deployment view of a system by using deployment diagrams that
represent the topology of the processors and devices on which your system executes. Fig 5.4.3 is
an example of three executable components that reside on the node named KioskSever. Instances
of classes may also reside on nodes, such as the anonymous instance of LoadAgent on the node
named Router. The two different methods shown for modeling the location of a component in fig
5.4.3 are each acceptable depending on what aspect you are trying to visualize. The first form
provides a visual cue about spatial separation and grouping of components while the second is
useful when the location of an element is secondary to its structure or when you want to show the
redistribution of a component over time.

Figure 5.4.3 Location

5.5 Statechart Diagrams
A statechart diagram shows a state machine, focusing on the flow of control from state to state.
A state machine is a behavior that specifies the sequences of states an object goes through during
its lifetime in response to events, together with its responses to those events.
Common Properties:
A statechart diagram is a special kind of diagram and shares the same common properties as do
all other diagrams like a name and graphical contents that are a projection into a model. What
distinguishes a state chart diagram from other diagrams is its content.
Content:
Statechart diagrams commonly contain:
 Simple states and composite states
 Transitions including events and actions
Common Uses:
When we model the dynamic aspects of a system, a class or a use case, we will use statechart
diagrams in one way:
 To model reactive (event-driven) objects.
Common Modeling Techniques:
Modeling Reactive Objects:
To model a reactive object:
 Choose the context for the state machine, whether it is a class, a use case or the system as
a whole.
 Choose the initial and final states for the object.
 Decide on the stable states of the object. Start with the high-level states of the object and
only then consider its possible substates.
 Decide on the meaningful partial ordering of stable states over the lifetime of the object.
 Decide on the events that may trigger a transition from state to state.
 Attach actions to these transitions and/or to these states.
 Consider ways to simplify your machine by using substates, branches, forks, joins and
history states.
 Check that all states are reachable under some combination of events.
 Check that no state is a dead end.
 Trace through the state machine, either manually or by using tools, to check it against
expected sequences of events and their responses.

Consider the following example: