here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
related properties, Hibernate can observe inconsistencies because of race conditions
caused by the other actor executing in parallel. In the case of Java,
the java.util.concurrent.atomic 23 package introduced an API for updating
fields specifically to maintain concurrency properties such as those given
by volatile fields. However, this requires mixing different APIs and is only
restricted to field semantics.
Other language guarantees that need to be maintained are for instance constraints
on method invocations. For instance, active objects require that their
methods are not executed directly but via an indirection that ensures that the
method is executed asynchronously by the active object’s thread. With Join
Java [Itzstein and Jasiunas, 2003], execution constraints can be more complex.
It allows the developer to define join patterns that need to be fulfilled before a
method is activated. Using reflection to circumvent these constraints can have
undesired effects. Thus, depending on the use case, even reflective invocation
should be able to preserve the constraints specified by such methods.
Another complication comes from the vision of a multi-language VM. In
this scenario it is insufficient to make reflection aware of a single set of desired
guarantees. Instead, additional flexibility is required. Language semantics
such as isolation for an actor language are to be implemented on top of
the VM, based on a unifying abstraction. A multi-language VM will need
to be able to distinguish between situations where an enforcement of guarantees
is required and situations where enforcement is not desired. Kiczales
et al. [1997] and Tanter [2009] discuss how to scope reflection. Similarly, in
the context of multi-language VMs, it also needs to be possible to scope, i. e.,
restrict reflection to circumvent a small set of language guarantees only, while
maintaining others.
Reflection and Security The power of reflection is also an issue for security.
Therefore, the JVM and CLI provide infrastructure to manage reflection in
a way that allows them to restrict the reflective capabilities depending on a
security context. For the JVM the SecurityManager 24 is consulted for reflective
operations to verify that the necessary permissions are given. The CLI
provides similar mechanisms with its System.Security facilities. 25
The SecurityManager provides the flexibility to customize the check that
is performed for reflective operations. However, the offered interface is very
23 http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/atomic/packagesummary.html
24 http://docs.oracle.com/javase/7/docs/api/java/lang/SecurityManager.html
25 http://msdn.microsoft.com/en-us/library/stfy7tfc.aspx
80