here - Stefan-Marr.de

3.3. Common Problems for the Implementation of Concurrency Abstractions
minimal and does not provide the flexibility required for multi-language VMs.
For instance, the JVM relies on the problematic method setAccessible(bool),
which needs to be called to disable the security checks to circumvent language
restrictions. While setAccessible(bool) is covered by the SecurityManager
and its handler can be customized with another security strategy, the object
can be manipulated at will once obj.setAccessible(true) succeeded. 26
Thus, enforcing complex policies is not possible with this approach. Another
weak point is that the security infrastructure only considers fields that are
protected by Java language semantics. Thus, public fields of an object are not
covered by the security manager, which therefore cannot be used to express
concurrency policies for all objects.
Conclusion Reflection in the form it is supported on today’s VMs is not
designed to enable the required fine-grained control. Common approaches
provide only limited security-related mechanisms to restrict the reflective capabilities.
However, the provided abstractions are not expressive enough to
distinguish between different parts of a language. For instance, is not possible
to freely use reflection on objects inside of an actor to circumvent their private
field restrictions, without risking to have concurrency issues with objects that
belong to another actor, because the reflection would also circumvent these
concurrency restrictions.
Thus, reflection needs to provide the ability to do metaprogramming with
the possibility to circumvent only certain language restrictions, while adhering
to other parts of the language, for instance concurrency-related semantics.
3.3.6. Summary
As argued in this section, the implementation of proper isolation, scheduling
guarantees, and immutability is problematic with today’s VMs. For the implementation
of isolation, language designers have to make a tradeoff between
semantic guarantees, performance, and implementation complexity. To ensure
progress in models such as actors or CSP, language designers have to
be able to rely on scheduling guarantees which are typically implemented on
top of the VM, and thus, handling of computationally expensive or blocking
operations undermines the required guarantees.
Immutability also requires proper enforcement to yield its full engineering
benefit, especially in the setting of a multi-language VM for concurrent
26 http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/reflect/Field.html#set
(java.lang.Object,java.lang.Object)
81