here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
defines that each object is implicitly associated with a lock to enable synchronized
methods. The metadata associated with every method, which is part of
the ISA, has therefore to contain the ImplFlags.Synchronized flag, according
to the specification. Other atomic and synchronization operations are defined
in terms of primitives for instance for compare-and-swap, atomic update operations,
and explicit memory barriers, i. e., fences.
Beyond these mechanisms, the specification also discusses the functions
Parallel.For, Parallel.ForEach, and Parallel.While. They are part of the
standard library to provide parallel looping constructs. With the notion of
AppDomains it also includes a mechanism to facilitate communicating isolates,
which is discussed in Sec. 3.1.2.3.
Java Virtual Machine (JVM) The analysis of the Java Virtual Machine (JVM)
relies on the specification [Lindholm et al., 2012] and considers the OpenJDK7
for details about the standard library.
The JVM provides a programming model that is solely based on shared
memory. It relies on the memory model defined by the Java Language Specification
[Gosling et al., 2012] to establish the semantics of operations on this
shared memory and the visibility of changes to the memory between operations
and threads. The semantics are defined in terms of happens-before relationships
between operations. For example, synchronization operations as
well as reading and writing of volatile fields have specific semantics, which
constrain optimizations of compilers and processors to guarantee that the
observable ordering of operations is deterministic. Similar to the CLI, these
semantics are realized in terms of the implicit semantics implemented in the
VM and its JIT compiler.
In addition to the memory model, locking-based abstractions are a key concurrency
feature, because every object is implicitly associated with a lock to
enable synchronized methods and can also be used as a condition variable.
Methods can carry the ACC_SYNCHRONIZED flag, and the two bytecode instructions
monitorenter and monitorexit expose the object’s lock on the ISA level
to enable the implementation of synchronized blocks. A note in the specification
also hints at Object.wait and Object.notify being realized as primitives.
In contrast to the CLI, the JVM does not have the notion of volatile
variables, because it does not have closures. Instead, it provides only volatile
object fields, which are realized in the ISA by a the ACC_VOLATILE flag in the
object field’s metadata.
46