VMMutex

java.lang.Object
- com.oracle.svm.core.locks.VMMutex

All Implemented Interfaces:

AutoCloseable
```
public class VMMutex
extends Object
implements AutoCloseable
```
A mutex that has minimal requirements on Java code. The implementation does not perform memory allocation, exception unwinding, or other complicated operations. This allows it to be used in early startup and shutdown phases of the VM, as well as to coordinate garbage collection. Higher-level code that does not have these restrictions should use regular locks from the JDK instead, i.e., implementations of Lock. It is not possible to allocate new VM mutexes at run time. All VM mutexes must be allocated during image generation. They are initialized during startup of the VM, i.e., every VM mutex consumes resources and contributes to VM startup time. This class is almost an abstract base class for VMMutex. Sub-classes replace instances of VMMutex with platform-specific implementations.

Constructor Summary

Constructors
Constructor and Description

VMMutex()

Constructors
Constructor and Description
`VMMutex()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`assertIsNotLocked(String message)` This method is potentially racy and must only be called in places where we can guarantee that no incorrect `AssertionError`s are thrown because of potential races.
`void`	`assertIsOwner(String message)`
`void`	`assertNotOwner(String message)`
`void`	`clearCurrentThreadOwner()`
`void`	`clearUnspecifiedOwner()`
`void`	`close()` Releases the lock when locking using a try-with-resource statement.
`void`	`guaranteeIsOwner(String message)`
`void`	`guaranteeNotOwner(String message)`
`boolean`	`isOwner()`
`VMMutex`	`lock()` Acquires the lock, with thread status transitions, blocking until the lock is available.
`void`	`lockNoTransition()` Like VMMutex.lock(), but without a thread status transitions.
`void`	`lockNoTransitionUnspecifiedOwner()` Like VMMutex.lockNoTransition(), but the lock owner is set to an unspecified isolate thread.
`void`	`setOwnerToCurrentThread()`
`void`	`setOwnerToUnspecified()`
`void`	`unlock()` Releases the lock.
`void`	`unlockNoTransitionUnspecifiedOwner()` Like VMMutex.unlock().
`void`	`unlockWithoutChecks()` Releases the lock, without checking the result.

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

- Constructor Detail
  - VMMutex
```
public VMMutex()
```
- Method Detail
  - lock
```
public VMMutex lock()
```
    Acquires the lock, with thread status transitions, blocking until the lock is available. Upon acquiring the mutex successfully, the current isolate thread is registered as the lock owner. Recursive locking is not allowed.
    
    Returns:
    
    "this" for use in a try-with-resources statement.
  - lockNoTransition
```
public void lockNoTransition()
```
    Like VMMutex.lock(), but without a thread status transitions. E.g., for locking before everything is set up to track transitions. This method can only be called from uninterruptible code as it prevents the VM from entering a safepoint while waiting on the lock, which could result in deadlocks like the following:
    - Thread A calls mutex.lockNoTransition() and acquires the mutex
    - Thread B calls mutex.lockNoTransition() and is blocked
    - Thread A still holds the mutex but needs to trigger a GC. However, the safepoint can't be initiated as Thread B is still in the Java state but blocked in native code.
  - lockNoTransitionUnspecifiedOwner
```
public void lockNoTransitionUnspecifiedOwner()
```
    Like VMMutex.lockNoTransition(), but the lock owner is set to an unspecified isolate thread. Only use this method in places where CurrentIsolate.getCurrentThread() can return null.
  - unlock
```
public void unlock()
```
    Releases the lock.
  - unlockNoTransitionUnspecifiedOwner
```
public void unlockNoTransitionUnspecifiedOwner()
```
    Like VMMutex.unlock(). Only use this method if the lock was acquired via VMMutex.lockNoTransitionUnspecifiedOwner().
  - unlockWithoutChecks
```
public void unlockWithoutChecks()
```
    Releases the lock, without checking the result.
  - close
```
public final void close()
```
    Releases the lock when locking using a try-with-resource statement.
    This is not annotated with Uninterruptible because using try-with-resources implicitly calls Throwable.addSuppressed(Throwable), which I can not annotate.
    
    Specified by:
    
    close in interface AutoCloseable
  - assertIsOwner
```
public final void assertIsOwner(String message)
```
  - assertNotOwner
```
public final void assertNotOwner(String message)
```
  - assertIsNotLocked
```
public final void assertIsNotLocked(String message)
```
    This method is potentially racy and must only be called in places where we can guarantee that no incorrect AssertionErrors are thrown because of potential races.
  - guaranteeIsOwner
```
public final void guaranteeIsOwner(String message)
```
  - guaranteeNotOwner
```
public final void guaranteeNotOwner(String message)
```
  - isOwner
```
public final boolean isOwner()
```
  - setOwnerToCurrentThread
```
public void setOwnerToCurrentThread()
```
  - setOwnerToUnspecified
```
public void setOwnerToUnspecified()
```
  - clearCurrentThreadOwner
```
public void clearCurrentThreadOwner()
```
  - clearUnspecifiedOwner
```
public void clearUnspecifiedOwner()
```

Class VMMutex

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VMMutex

Method Detail

lock

lockNoTransition

lockNoTransitionUnspecifiedOwner

unlock

unlockNoTransitionUnspecifiedOwner

unlockWithoutChecks

close

assertIsOwner

assertNotOwner

assertIsNotLocked

guaranteeIsOwner

guaranteeNotOwner

isOwner

setOwnerToCurrentThread

setOwnerToUnspecified

clearCurrentThreadOwner

clearUnspecifiedOwner