here - Stefan-Marr.de

3.3. Common Problems for the Implementation of Concurrency Abstractions
3.3.5. Reflection
Reflection, i. e., metaprogramming is used to circumvent the restrictions of
a particular language or to modify and extend its language semantics. When
reflection is used, language guarantees are no longer enforced and developers
have to take care not to violate inherent assumptions made by the rest of the
program. In sequential programs this is common practice and used widely
for a variety of use cases.
Bypassing Language Restrictions Many common use cases bypass restrictions
imposed by language semantics. Examples are the modification of supposedly
immutable objects or bypassing restrictions to access protected fields.
These capabilities are often desirable to enable the implementation of frameworks
that work on any given object by dynamically reflecting over it. Widely
used examples are unit testing frameworks reflecting over classes to execute
tests, mockup generators to facilitate testing without the need to explicitly
define test classes, object-relational mappers (ORM) to bridge between application
and database for persistence, and other frameworks for general marshalling
and serialization.
Note that the characteristics of these use cases are very similar. The main reflective
features used include inspecting objects, invoking methods, or changing
fields reflectively. While language restrictions such as modifiers for private
and protected fields need to be circumvented, concurrency-related language
properties should not be circumvented in these use cases. Instead, in most
situations reflection should be able to respect these language guarantees.
Concurrency properties need to be maintained during reflection. Since the
described use cases are ubiquitous, it is impractical to ban the use of reflection
to guarantee the semantics of a particular concurrent programming concept.
Instead, a VM needs to provide a mechanism that makes it safe to use reflection
for application purposes while maintaining the desired part of the
language guarantees, in this case the concurrency properties.
Imagine an application implemented in an actor language that uses a reflective
object-relational mapping (ORM) system such as Hibernate [Bauer
and King, 2005], which by itself is not actor-aware. One actor tries to persist
an object owned by another actor. Hibernate would use reflection to
read the state. Since the Java reflection API 22 does not preserve concurrency-
22 http://docs.oracle.com/javase/6/docs/api/java/lang/reflect/package-summary.h
tml
79