Active Object

 

This article is extracted from POSA2 as a reading note.

The Active Object design pattern decouples method execution from method invocation to enhance concurrency and simplify synchronized access to objects that reside in their own threads of control.

An active object consists of six components:

Proxy: A proxy provides an interface that allows clients to invoke publicly accessible methods on an active object. The use of a proxy  permits applications to program using standard strongly typed language features, rather than passing loosely typed messages between threads. The proxy resides in the client's thread.

Method request: When a client invokes a method defined by the proxy  it triggers the construction of a method request object. A method request contains the context information, such as a method's parameters, necessary to execute a specific method invocation and return any result to the client. A method request class defines an interface for executing the methods of an active object. This interface also contains guard methods that can be used to determine when a method request can be executed. For every public method offered by a proxy that requires synchronized access in the active object, the method request class is subclassed to create a concrete method request class.

Activation list: A proxy inserts the concrete method request it creates into an activation list. This list maintains a bounded buffer of pending method requests created by the proxy and keeps track of which method requests can execute. The activation list decouples the client thread where the proxy resides from the thread  where the servant method is executed, so the two threads can run concurrently. The internal state of the activation list must therefore be serialized to protect it from concurrent access.

Scheduler: A scheduler runs in a different thread than its client proxies, namely in the active object's thread. It decides which method requst to execute next on an active object. This scheduling decision is based on various criteria, such as ordering - the order in which methods are called on the active object, or certain properties of an active object, such as its state. A scheduler can evaluate these properties using the method requests' guards, which determine when it is possible to execute the method request. A scheduler uses an activation list to manage method requests that are pending execution. Method requests are inserted in an activation list by a proxy when clients invoke one of its methods.

Servant: A servant defines the behavior and state that is modeled as an active object. The methods a servant implements correspond to  the interface of the proxy and method requests the proxy creates. It may also contain other predicate methods that method requests can use to implement their guards. A servant method is invoked when  its associated method request is executed by a scheduler. Thus, it  executes in its scheduler's thread.

Future: When a client invokes a method on a proxy it receives a future. This future allows the client to obtain the result of the method invocation after the servant finishes executing the method. Each future reserves space for the invoked method to store its result. When a client wants to obtain this result, it can rendezvous with the future, either blocking or polling until the result is computed and stored into the future.