The distributer pattern is an active object pattern that separates the
platform specific responsibility of event/state detection from the
distribution of the those change indications to interested clients.
The Distributer pattern is an active object analog of the Subject as described
by the GOF Observer pattern.
The separation of concerns provided by Distributer pattern allows
for applications depenedent upon the state change information provided
by the Distributer to be reused on platforms where the source of the
state change is different.
Also Known As
Alarm indications typically have many interested clients in a
telecommunication product. Many applications components that
rely on these alarm indications can be used on different
products and platforms, where the source of the alarm varies.
By separating the software that determines the state
of the alarm indications (Controller) from the software that
distributes those state indications (Distributer), only the
Controller will need to be rewritten for the new platform.
This pattern is very useful in applications where asynchronous
state changes (events) must be distributed to many clients, and
the application may execute on more than one platform.
There are three participants in the Distributer state pattern.
The Distributer itself is responsible for disseminating state change
information to Clients using the
The Controller is responsible for determining the current state
of the distributer using system specific means. For example,
one implementation of the Controller might handle an interrupt
from a particular piece of hardware on one system, and another
implementation might poll a different hardware device on another
Note that the Distributer implementation does not change and that
the Distributer knows nothing of its Clients or Controllers.
The Controller determines the current state by system specific
means, and sends change-of-state requests to the Distributer
In response, the Distributer stores the current state and
and notifies any appropriate clients which have requests
pending with the distributer. The Distributer typically
maintains a linked list of pending requests.
The Distributer has the role of the Subject and the Client
has the role of the Observer as described in the
How does the pattern support its objectives? What are the trade-offs
and results of using the pattern? What aspect of system
structure does it let you var independently?
What pitfalls, hints, or techniques should you be aware of when
implementing the pattern? Are there language-specific issues?
The Notification Pattern
describes the relationship between the Distributer (Subject) and
the Client (Observer). The difference lies in the Distributer's
implementation where the Controller is seperated from the
Distributer. Thus, the cause of Distributer state changes may
vary independently of the means of notifying clients of those