here - Stefan-Marr.de

2. Context and Motivation
Clojure Agents The Clojure programming language offers a variation inspired
by the active objects pattern called agents. 10 An agent represents a
resource with a single atomically mutable state cell. However, the state is
modified only by the agent itself. The agent receives update functions asynchronously.
An update function takes the old state and produces a new state.
The execution is done in a dedicated thread, so that at most one update function
can be active for a given agent at any time. Other threads will always
read a consistent state of the agent at any time, since the state of the agent is
a single cell and read atomically.
Specific to agents is the integration with the Clojure language and the
encouraged usage patterns. Clojure aims to be “predominantly a functional
programming language” 11 that relies on immutable, persistent data structures.
Therefore, it encourages the use of immutable data structures as the state
of the agent. With these properties in mind, agents provide a more restrictive
model than common active objects, and if these properties would be enforced,
it could be classified as a mechanism for communicating isolates. However, Clojure
does not enforce the use of immutable data structures as state of the
agent, but allows for instance the use of unsafe Java objects.
The described set of intentions and the missing guarantees qualify agents
as an example for later chapters. Thus, it is described here in more detail.
1 ( def cnt ( agent 0))
2 ( println @cnt ) ; prints 0
3
4 ( send cnt + 1)
5 ( println @cnt ) ; might print 0 or 1, because of data race
6
7 ( let [ next-id ( promise )]
8 ( send cnt (fn [ old-state ]
9 ( let [ result (+ old-state 1)]
10 ( deliver next-id result ) ; return resulting id to sender
11 result )))
12 @next-id ) ; reliably read of the update function ’s result
Listing 2.1: Clojure Agent example
Lst. 2.1 gives a simple example of how to implement a counter agent in Clojure,
and how to interact with it. First, line 1 defines a simple counter agent
named cnt with an initial value of 0. Printing the value by accessing it directly
10 http://clojure.org/agents
11 Clojure, Rich Hickey, access date: 20 July 2012 http://clojure.org/
28