MultiThreadedMonitorSupport

java.lang.Object
- com.oracle.svm.core.monitor.MonitorSupport
- - com.oracle.svm.core.monitor.MultiThreadedMonitorSupport

```
public class MultiThreadedMonitorSupport
extends MonitorSupport
```
Implementation of synchronized-related operations.
Most objects used in synchronization operations have a dedicated memory in the object to store a ReentrantLock. The static analysis finds out which classes are used for synchronization (and thus need a monitor) and assigns a monitor offset to point to the slot for the monitor. The monitor is implemented with a ReentrantLock.
There are a few exceptions: String and DynamicHub objects never have monitor fields because we want instances in the image heap to be immutable. Arrays never have monitor fields because it would increase the size of every array and it is not possible to distinguish between arrays with different header sizes. See UniverseBuilder.canHaveMonitorFields(AnalysisType) for details.
Synchronization on String, arrays, and other types not detected by the static analysis (like synchronization via JNI) fall back to a monitor stored in MultiThreadedMonitorSupport.additionalMonitors.
Condition objects are used to implement Object.wait() and Object.notify(). When an object monitor needs a condition object, it is atomically swapped into its Target_java_util_concurrent_locks_ReentrantLock_NonfairSync.objectMonitorCondition field.

Field Summary

Fields
Modifier and Type	Field and Description
`static Set<Class<?>>`	`FORCE_MONITOR_SLOT_TYPES` Types that are used to implement the secondary storage for monitor slots cannot themselves use the additionalMonitors map.
`protected static String`	`NO_LONGER_UNINTERRUPTIBLE`

Constructor Summary

Constructors
Constructor and Description

MultiThreadedMonitorSupport()

Constructors
Constructor and Description
`MultiThreadedMonitorSupport()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`doRelockObject(Object obj, Object lockData)`
`protected void`	`doWait(Object obj, long timeoutMillis)`
`protected ReentrantLock`	`ensureLocked(Object obj)` Returns the lock of the object.
`ReentrantLock`	`getMonitorForTesting(Object obj)`
`protected static int`	`getMonitorOffset(Object obj)`
`protected AbstractQueuedSynchronizer.ConditionObject`	`getOrCreateCondition(ReentrantLock monitorLock, boolean createIfNotExisting)`
`protected ReentrantLock`	`getOrCreateMonitor(Object obj, boolean createIfNotExisting)`
`protected ReentrantLock`	`getOrCreateMonitorFromMap(Object obj, boolean createIfNotExisting)`
`protected ReentrantLock`	`getOrCreateMonitorFromObject(Object obj, boolean createIfNotExisting, int monitorOffset)`
`boolean`	`isLockedByAnyThread(Object obj)` Determines whether the object's monitor is locked by the current or any other thread.
`boolean`	`isLockedByCurrentThread(Object obj)` Implements the semantics of `Thread.holdsLock(java.lang.Object)`.
`protected static boolean`	`isMonitorCondition(Object obj)`
`protected static boolean`	`isMonitorLock(ReentrantLock lock)`
`protected static boolean`	`isMonitorLockSynchronizer(Object obj)`
`int`	`maybeAdjustNewParkStatus(int status)` Called from `Unsafe.park` when changing the current thread's state before parking the thread.
`void`	`monitorEnter(Object obj)` Implements the semantics of the monitorenter bytecode.
`void`	`monitorExit(Object obj)` Implements the semantics of the monitorexit bytecode.
`protected static ReentrantLock`	`newLockedMonitorForThread(org.graalvm.nativeimage.IsolateThread isolateThread, int recursionDepth)` Creates a new `ReentrantLock` that is locked by the provided thread.
`protected static ReentrantLock`	`newMonitorLock()`
`void`	`notify(Object obj, boolean notifyAll)` Implements the semantics of `Object.notify()` and `Object.notifyAll()`.
`Object`	`prepareRelockObject(Object obj)`

Methods inherited from class com.oracle.svm.core.monitor.MonitorSupport
singleton, wait

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - FORCE_MONITOR_SLOT_TYPES
```
public static final Set<Class<?>> FORCE_MONITOR_SLOT_TYPES
```
    Types that are used to implement the secondary storage for monitor slots cannot themselves use the additionalMonitors map. That could result in recursive manipulation of the additionalMonitors map which could lead to table corruptions and double insertion of a monitor for the same object. Therefore these types will alawys get a monitor slot.
  - NO_LONGER_UNINTERRUPTIBLE
```
protected static final String NO_LONGER_UNINTERRUPTIBLE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MultiThreadedMonitorSupport
```
public MultiThreadedMonitorSupport()
```
- Method Detail
  - maybeAdjustNewParkStatus
```
public int maybeAdjustNewParkStatus(int status)
```
    Description copied from class: MonitorSupport
    
    Called from Unsafe.park when changing the current thread's state before parking the thread. When the thread is parked due to a monitor operation, we need to alter the new thread state so Thread.getState() gives the expected result.
    
    Specified by:
    
    maybeAdjustNewParkStatus in class MonitorSupport
  - monitorEnter
```
public void monitorEnter(Object obj)
```
    Description copied from class: MonitorSupport
    
    Implements the semantics of the monitorenter bytecode.
    
    Specified by:
    
    monitorEnter in class MonitorSupport
  - monitorExit
```
public void monitorExit(Object obj)
```
    Description copied from class: MonitorSupport
    
    Implements the semantics of the monitorexit bytecode.
    
    Specified by:
    
    monitorExit in class MonitorSupport
  - prepareRelockObject
```
public Object prepareRelockObject(Object obj)
```
    Specified by:
    
    prepareRelockObject in class MonitorSupport
  - doRelockObject
```
public void doRelockObject(Object obj,
                           Object lockData)
```
    Specified by:
    
    doRelockObject in class MonitorSupport
  - isLockedByCurrentThread
```
public boolean isLockedByCurrentThread(Object obj)
```
    Description copied from class: MonitorSupport
    
    Implements the semantics of Thread.holdsLock(java.lang.Object).
    
    Specified by:
    
    isLockedByCurrentThread in class MonitorSupport
  - isLockedByAnyThread
```
public boolean isLockedByAnyThread(Object obj)
```
    Description copied from class: MonitorSupport
    
    Determines whether the object's monitor is locked by the current or any other thread.
    
    Specified by:
    
    isLockedByAnyThread in class MonitorSupport
  - doWait
```
protected void doWait(Object obj,
                      long timeoutMillis)
               throws InterruptedException
```
    Specified by:
    
    doWait in class MonitorSupport
    
    Throws:
    
    InterruptedException
  - notify
```
public void notify(Object obj,
                   boolean notifyAll)
```
    Description copied from class: MonitorSupport
    
    Implements the semantics of Object.notify() and Object.notifyAll().
    
    Specified by:
    
    notify in class MonitorSupport
  - ensureLocked
```
protected ReentrantLock ensureLocked(Object obj)
```
    Returns the lock of the object.
  - getMonitorOffset
```
protected static int getMonitorOffset(Object obj)
```
  - getOrCreateMonitor
```
protected final ReentrantLock getOrCreateMonitor(Object obj,
                                                 boolean createIfNotExisting)
```
  - getOrCreateMonitorFromObject
```
protected ReentrantLock getOrCreateMonitorFromObject(Object obj,
                                                     boolean createIfNotExisting,
                                                     int monitorOffset)
```
  - getOrCreateMonitorFromMap
```
protected ReentrantLock getOrCreateMonitorFromMap(Object obj,
                                                  boolean createIfNotExisting)
```
  - newMonitorLock
```
protected static ReentrantLock newMonitorLock()
```
  - newLockedMonitorForThread
```
protected static ReentrantLock newLockedMonitorForThread(org.graalvm.nativeimage.IsolateThread isolateThread,
                                                         int recursionDepth)
```
    Creates a new ReentrantLock that is locked by the provided thread. This requires patching of internal state, since there is no public API in ReentrantLock to do that (for a good reason, because it is a highly unusual operation).
  - isMonitorLock
```
protected static boolean isMonitorLock(ReentrantLock lock)
```
  - isMonitorLockSynchronizer
```
protected static boolean isMonitorLockSynchronizer(Object obj)
```
  - getMonitorForTesting
```
public ReentrantLock getMonitorForTesting(Object obj)
```
  - getOrCreateCondition
```
protected AbstractQueuedSynchronizer.ConditionObject getOrCreateCondition(ReentrantLock monitorLock,
                                                                          boolean createIfNotExisting)
```
  - isMonitorCondition
```
protected static boolean isMonitorCondition(Object obj)
```

Class MultiThreadedMonitorSupport

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.oracle.svm.core.monitor.MonitorSupport

Methods inherited from class java.lang.Object

Field Detail

FORCE_MONITOR_SLOT_TYPES

NO_LONGER_UNINTERRUPTIBLE

Constructor Detail

MultiThreadedMonitorSupport

Method Detail

maybeAdjustNewParkStatus

monitorEnter

monitorExit

prepareRelockObject

doRelockObject

isLockedByCurrentThread

isLockedByAnyThread

doWait

notify

ensureLocked

getMonitorOffset

getOrCreateMonitor

getOrCreateMonitorFromObject

getOrCreateMonitorFromMap

newMonitorLock

newLockedMonitorForThread

isMonitorLock

isMonitorLockSynchronizer

getMonitorForTesting

getOrCreateCondition

isMonitorCondition