here - Stefan-Marr.de

3.3. Common Problems for the Implementation of Concurrency Abstractions
introducing additional preemptive OS threads that schedule actors, i. e., tasks.
Karmani et al. propose to use a monitoring thread. This thread will spawn
additional threads if it does not observe progress. However, there are limits
to the approach and it requires tradeoffs between application responsiveness,
overhead, and monitoring precision. Furthermore, it can add complexity to
the implementation since it prescribes how actors can be represented.
Applicability beyond Actors Again, the problem of scheduling guarantees
is not specific to actor-based concepts. Instead, it has to be carefully considered
for any concurrent system that implies any notion of overall forward
progress. The absence of such required guarantees is for instance visible in
Clojure. Its agent construct makes a clear distinction between normal operations,
and operations that result in long running computations or blocking
I/O. For the latter kind of operations, Clojure offers the (send-off) construct,
which will use a new thread to execute the operation to avoid starvation of
other agents.
Conclusion While ad hoc solutions used today have drawbacks, they provide
the flexibility to implement custom policies that can be adapted precisely
to the characteristics of a specific concurrent programming concept. The main
problem with these approaches is the missing control over primitive execution
and computationally expensive operations, which can prevent these ad hoc
solutions from enforcing their policies.
3.3.4. Immutability
Immutability is a desirable guarantee to simplify reasoning over programs in
a concurrent setting, and it facilitates techniques such as replication, or constant
propagation. However, in today’s VMs, immutability is guaranteed with
limitations only. Often it is provided at the language-level only and not preserved
at the VM level. For instance, the JVM and CLI allow a programmer to
change final or readonly object fields via reflection. Nonetheless, it is used
for optimizations, and the JVM specification includes a warning on the visibility
of such reflective changes, because JIT compilers for the JVM perform
constant propagation for such fields.
Weak immutability is a workaround for missing functionality. While immutability
by itself is desirable, notions of weak immutability have been used
77