4th International Conference on Principles and Practices ... - MADOC

2. FRAMEWORK
The Framework for Unified Resource Management (Furm)
represents dependencies among resources using trees [12]. In a
resource tree, given a parent resource P and a child resource C, C
is dependent on P. That is, once P is closed, C has no further use.
By extension, given any two resources X and Y where X is an
ancestor of Y, Y is dependent on X, either directly or indirectly.
All resources are therefore dependent on the tree’s root resource.
This resource tree abstraction is primarily useful in two ways.
First, the tree provides a unified way to manage resources. This
fills the gap left by Java’s Closeable interface. The resource tree
provides a consistent way to view resources, and makes it
possible for all resources to be released in an identical manner.
Second, the resource tree materializes resource dependencies in
an explicit fashion. While an input stream might be associated
with a socket, it may not be evident to any code using the stream
that this is the case. However, if the socket and its streams are
part of the same resource tree, the relationship becomes clear.
The connection in the tree ties a parent and child together
logically and simply.
Furm models two types of dependencies: substantive
dependencies and logical dependencies. Figures 2-1 and 2-2
illustrate substantive and logical dependencies, respectively.
Substantive dependencies are those dependencies that might be
described as concrete, physical, or real dependencies. These are
forced dependencies, or dependencies in which the child resource
truly has no meaning in the absence of the parent resource. The
resource dependency examples used so far have all been
substantive dependencies.
Logical dependencies are semantic dependencies, or groupings of
resources. For example, the input and output streams used by a
block of code may not have any true, enforced dependencies, but
they may still be logically dependent, in that without both,
Socket
execution cannot successfully proceed. It is therefore useful to
represent them as siblings with a common parent. Neither the
input stream nor the output stream has a substantive dependency
on the other, but they are logically connected. Having a common
parent materializes this relationship. In logical dependencies, the
parent will often be a pseudo-resource, i.e., the parent represents a
group of resources, and does not itself represent a particular
resource. It exists to support the semantic relationship of its
children. A common use of logical dependencies is to group all
the resources of a segment of a program. This might be a code
block, a specific object, or a thread of execution. Figure 2-3
shows a resource group associated with a thread, which contains a
database connection and a socket, each with its own
dependencies.
It has been shown that the resource tree can represent
dependencies among resources. In addition, Furm propagates
resource releases from ancestors to descendents. If a resource in
the tree is released, then all of its children will be released, and in
turn the children’s children, etc. Rather than releasing a number
of individual resources, only the parent resource needs to be
explicitly released. Entire subtrees of resources can be released
with a single call. This has the immediate effect that cleanup
code, with its large code overhead, is greatly reduced.
2.1 Using Furm
Here we present a simple method fetch(), with the job of
connecting to a server, sending a message, and returning the
response to the caller. (See Figure 2-4.) In the event of failure,
the response is null.
This method is implemented correctly, with respect to resource
management. The three resources used are a Socket, an
InputStream, and an OutputStream. The ByteArrayOutputStream
is not considered a resource here, because it does not need to be
closed.
While the task of this code is simple, the decision to correctly
close resources and handle all checked exceptions – as opposed to
discarding them or allowing them to propagate to the caller – has
caused massive code expansion. If exceptions could be safely
ignored, this method could be reduced from 44 lines to only 18.
Note especially how the nested try-finally blocks turn cleanup, a
conceptually minor detail, into the most dominant detail.
Socket Input Stream
Socket Output Stream
Figure 2-1. Substantive dependencies
Resource Group
Resource Group
Database
Connection
Socket
File Input Stream
File Output Stream
Statement Socket Input Stream Socket Output Stream
Figure 2-2. Logical dependencies
Figure 2-3. An example resource tree
116