Package com.sun.ts.lib.util.sec.misc

# Class Unsafe

java.lang.Object
com.sun.ts.lib.util.sec.misc.Unsafe

public final class Unsafe extends Object
A collection of methods for performing low-level, unsafe operations. Although the class and all methods are public, use of this class is limited because only trusted code can obtain instances of it.

Author:
  John R. Rose
See Also:
  - `getUnsafe()`

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final int`
  `INVALID_FIELD_OFFSET`
  This constant differs from all results that will ever be returned from `staticFieldOffset(java.lang.reflect.Field)`, `objectFieldOffset(java.lang.reflect.Field)`, or `arrayBaseOffset(java.lang.Class)`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `int`
  `addressSize()`
  Report the size in bytes of a native pointer, as stored via `putAddress(long, long)`.
  `Object`
  `allocateInstance(Class cls)`
  Allocate an instance but do not run any constructor.
  `long`
  `allocateMemory(long bytes)`
  Allocates a new block of native memory, of the given size in bytes.
  `int`
  `arrayBaseOffset(Class arrayClass)`
  Report the offset of the first element in the storage allocation of a given array class.
  `int`
  `arrayIndexScale(Class arrayClass)`
  Report the scale factor for addressing elements in the storage allocation of a given array class.
  `final boolean`
  `compareAndSwapInt(Object o, long offset, int expected, int x)`
  Atomically update Java variable to `x` if it is currently holding `expected`.
  `final boolean`
  `compareAndSwapLong(Object o, long offset, long expected, long x)`
  Atomically update Java variable to `x` if it is currently holding `expected`.
  `final boolean`
  `compareAndSwapObject(Object o, long offset, Object expected, Object x)`
  Atomically update Java variable to `x` if it is currently holding `expected`.
  `void`
  `copyMemory(long srcAddress, long destAddress, long bytes)`
  Sets all bytes in a given block of memory to a copy of another block.
  `Class`
  `defineClass(String name, byte[] b, int off, int len)`
  `Class`
  `defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain)`
  Tell the VM to define a class, without security checks.
  `void`
  `ensureClassInitialized(Class c)`
  Ensure the given class has been initialized.
  `int`
  `fieldOffset(Field f)`
  Deprecated.
  As of 1.4.1, use `staticFieldOffset(java.lang.reflect.Field)` for static fields and `objectFieldOffset(java.lang.reflect.Field)` for non-static fields.
  `void`
  `freeMemory(long address)`
  Disposes of a block of native memory, as obtained from `allocateMemory(long)` or `reallocateMemory(long, long)`.
  `long`
  `getAddress(long address)`
  Fetches a native pointer from a given memory address.
  `boolean`
  `getBoolean(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `boolean`
  `getBoolean(Object o, long offset)`
  `boolean`
  `getBooleanVolatile(Object o, long offset)`
  Volatile version of `getBoolean(Object, long)`
  `byte`
  `getByte(long address)`
  Fetches a value from a given memory address.
  `byte`
  `getByte(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `byte`
  `getByte(Object o, long offset)`
  `byte`
  `getByteVolatile(Object o, long offset)`
  Volatile version of `getByte(Object, long)`
  `char`
  `getChar(long address)`
  `char`
  `getChar(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `char`
  `getChar(Object o, long offset)`
  `char`
  `getCharVolatile(Object o, long offset)`
  Volatile version of `getChar(Object, long)`
  `double`
  `getDouble(long address)`
  `double`
  `getDouble(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `double`
  `getDouble(Object o, long offset)`
  `double`
  `getDoubleVolatile(Object o, long offset)`
  Volatile version of `getDouble(Object, long)`
  `float`
  `getFloat(long address)`
  `float`
  `getFloat(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `float`
  `getFloat(Object o, long offset)`
  `float`
  `getFloatVolatile(Object o, long offset)`
  Volatile version of `getFloat(Object, long)`
  `int`
  `getInt(long address)`
  `int`
  `getInt(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `int`
  `getInt(Object o, long offset)`
  Fetches a value from a given Java variable.
  `int`
  `getIntVolatile(Object o, long offset)`
  Volatile version of `getInt(Object, long)`
  `int`
  `getLoadAverage(double[] loadavg, int nelems)`
  Gets the load average in the system run queue assigned to the available processors averaged over various periods of time.
  `long`
  `getLong(long address)`
  `long`
  `getLong(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `long`
  `getLong(Object o, long offset)`
  `long`
  `getLongVolatile(Object o, long offset)`
  Volatile version of `getLong(Object, long)`
  `Object`
  `getObject(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `Object`
  `getObject(Object o, long offset)`
  Fetches a reference value from a given Java variable.
  `Object`
  `getObjectVolatile(Object o, long offset)`
  Fetches a reference value from a given Java variable, with volatile load semantics.
  `short`
  `getShort(long address)`
  `short`
  `getShort(Object o, int offset)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `short`
  `getShort(Object o, long offset)`
  `short`
  `getShortVolatile(Object o, long offset)`
  Volatile version of `getShort(Object, long)`
  `static Unsafe`
  `getUnsafe()`
  Provides the caller with the capability of performing unsafe operations.
  `void`
  `monitorEnter(Object o)`
  Lock the object.
  `void`
  `monitorExit(Object o)`
  Unlock the object.
  `long`
  `objectFieldOffset(Field f)`
  Report the location of a given static field, in conjunction with `staticFieldBase(java.lang.Class)`.
  `int`
  `pageSize()`
  Report the size in bytes of a native memory page (whatever that is).
  `void`
  `park(boolean isAbsolute, long time)`
  Block current thread, returning when a balancing `unpark` occurs, or a balancing `unpark` has already occurred, or the thread is interrupted, or, if not absolute and time is not zero, the given time nanoseconds have elapsed, or if absolute, the given deadline in milliseconds since Epoch has passed, or spuriously (i.e., returning for no "reason").
  `void`
  `putAddress(long address, long x)`
  Stores a native pointer into a given memory address.
  `void`
  `putBoolean(Object o, int offset, boolean x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putBoolean(Object o, long offset, boolean x)`
  `void`
  `putBooleanVolatile(Object o, long offset, boolean x)`
  Volatile version of `putBoolean(Object, long, boolean)`
  `void`
  `putByte(long address, byte x)`
  Stores a value into a given memory address.
  `void`
  `putByte(Object o, int offset, byte x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putByte(Object o, long offset, byte x)`
  `void`
  `putByteVolatile(Object o, long offset, byte x)`
  Volatile version of `putByte(Object, long, byte)`
  `void`
  `putChar(long address, char x)`
  `void`
  `putChar(Object o, int offset, char x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putChar(Object o, long offset, char x)`
  `void`
  `putCharVolatile(Object o, long offset, char x)`
  Volatile version of `putChar(Object, long, char)`
  `void`
  `putDouble(long address, double x)`
  `void`
  `putDouble(Object o, int offset, double x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putDouble(Object o, long offset, double x)`
  `void`
  `putDoubleVolatile(Object o, long offset, double x)`
  Volatile version of `putDouble(Object, long, double)`
  `void`
  `putFloat(long address, float x)`
  `void`
  `putFloat(Object o, int offset, float x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putFloat(Object o, long offset, float x)`
  `void`
  `putFloatVolatile(Object o, long offset, float x)`
  Volatile version of `putFloat(Object, long, float)`
  `void`
  `putInt(long address, int x)`
  `void`
  `putInt(Object o, int offset, int x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putInt(Object o, long offset, int x)`
  Stores a value into a given Java variable.
  `void`
  `putIntVolatile(Object o, long offset, int x)`
  Volatile version of `putInt(Object, long, int)`
  `void`
  `putLong(long address, long x)`
  `void`
  `putLong(Object o, int offset, long x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putLong(Object o, long offset, long x)`
  `void`
  `putLongVolatile(Object o, long offset, long x)`
  Volatile version of `putLong(Object, long, long)`
  `void`
  `putObject(Object o, int offset, Object x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putObject(Object o, long offset, Object x)`
  Stores a reference value into a given Java variable.
  `void`
  `putObjectVolatile(Object o, long offset, Object x)`
  Stores a reference value into a given Java variable, with volatile store semantics.
  `void`
  `putOrderedInt(Object o, long offset, int x)`
  Ordered/Lazy version of `putIntVolatile(Object, long, int)`
  `void`
  `putOrderedLong(Object o, long offset, long x)`
  Ordered/Lazy version of `putLongVolatile(Object, long, long)`
  `void`
  `putOrderedObject(Object o, long offset, Object x)`
  Version of `putObjectVolatile(Object, long, Object)` that does not guarantee immediate visibility of the store to other threads.
  `void`
  `putShort(long address, short x)`
  `void`
  `putShort(Object o, int offset, short x)`
  Deprecated.
  As of 1.4.1, cast the 32-bit offset argument to a long.
  `void`
  `putShort(Object o, long offset, short x)`
  `void`
  `putShortVolatile(Object o, long offset, short x)`
  Volatile version of `putShort(Object, long, short)`
  `long`
  `reallocateMemory(long address, long bytes)`
  Resizes a new block of native memory, to the given size in bytes.
  `void`
  `setMemory(long address, long bytes, byte value)`
  Sets all bytes in a given block of memory to a fixed value (usually zero).
  `Object`
  `staticFieldBase(Class c)`
  Deprecated.
  As of 1.4.1, use `staticFieldBase(Field)` to obtain the base pertaining to a specific `Field`.
  `Object`
  `staticFieldBase(Field f)`
  Report the location of a given static field, in conjunction with `staticFieldOffset(java.lang.reflect.Field)`.
  `long`
  `staticFieldOffset(Field f)`
  Report the location of a given field in the storage allocation of its class.
  `void`
  `throwException(Throwable ee)`
  Throw the exception without telling the verifier.
  `boolean`
  `tryMonitorEnter(Object o)`
  Tries to lock the object.
  `void`
  `unpark(Object thread)`
  Unblock the given thread blocked on `park`, or, if it is not blocked, cause the subsequent call to `park` not to block.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### INVALID_FIELD_OFFSET

    public static final int INVALID_FIELD_OFFSET
    This constant differs from all results that will ever be returned from `staticFieldOffset(java.lang.reflect.Field)`, `objectFieldOffset(java.lang.reflect.Field)`, or `arrayBaseOffset(java.lang.Class)`.
    See Also:
      - Constant Field Values

- ## Method Details

  - ### getUnsafe

    public static Unsafe getUnsafe()
    Provides the caller with the capability of performing unsafe operations. The returned `Unsafe` object should be carefully guarded by the caller, since it can be used to read and write data at arbitrary memory addresses. It must never be passed to untrusted code. Most methods in this class are very low-level, and correspond to a small number of hardware instructions (on typical machines). Compilers are encouraged to optimize these methods accordingly. Here is a suggested idiom for using unsafe operations:

    >      class MyTrustedClass {
    >        private static final Unsafe unsafe = Unsafe.getUnsafe();
    >        ...
    >        private long myCountAddress = ...;
    >        public int getCount() { return unsafe.getByte(myCountAddress); }
    >      }

    (It may assist compilers to make the local variable be `final`.)
    Throws:
      `SecurityException` - if a security manager exists and its `checkPropertiesAccess` method doesn't allow access to the system properties.

  - ### getInt

    public int getInt(Object o, long offset)
    Fetches a value from a given Java variable. More specifically, fetches a field or array element within the given object `o` at the given offset, or (if `o` is null) from the memory address whose numerical value is the given offset. The results are undefined unless one of the following cases is true:
    - The offset was obtained from `objectFieldOffset(java.lang.reflect.Field)` on the `Field` of some Java field and the object referred to by `o` is of a class compatible with that field's class.
    - The offset and object reference `o` (either null or non-null) were both obtained via `staticFieldOffset(java.lang.reflect.Field)` and `staticFieldBase(java.lang.Class)` (respectively) from the reflective `Field` representation of some Java field.
    - The object referred to by `o` is an array, and the offset is an integer of the form `B+N*S`, where `N` is a valid index into the array, and `B` and `S` are the values obtained by `arrayBaseOffset(java.lang.Class)` and `arrayIndexScale(java.lang.Class)` (respectively) from the array's class. The value referred to is the `N` th element of the array.
    If one of the above cases is true, the call references a specific Java variable (field or array element). However, the results are undefined if that variable is not in fact of the type returned by this method. This method refers to a variable by means of two parameters, and so it provides (in effect) a double-register addressing mode for Java variables. When the object reference is null, this method uses its offset as an absolute address. This is similar in operation to methods such as `getInt(long)`, which provide (in effect) a single-register addressing mode for non-Java variables. However, because Java variables may have a different layout in memory from non-Java variables, programmers should not assume that these two addressing modes are ever equivalent. Also, programmers should remember that offsets from the double-register addressing mode cannot be portably confused with longs used in the single-register addressing mode.
    Parameters:
      `o` - Java heap object in which the variable resides, if any, else null
      `offset` - indication of where the variable resides in a Java heap object, if any, else a memory address locating the variable statically
    Returns:
      the value fetched from the indicated Java variable
    Throws:
      `RuntimeException` - No defined exceptions are thrown, not even `NullPointerException`

  - ### putInt

    public void putInt(Object o, long offset, int x)
    Stores a value into a given Java variable. The first two parameters are interpreted exactly as with `getInt(Object, long)` to refer to a specific Java variable (field or array element). The given value is stored into that variable. The variable must be of the same type as the method parameter `x`.
    Parameters:
      `o` - Java heap object in which the variable resides, if any, else null
      `offset` - indication of where the variable resides in a Java heap object, if any, else a memory address locating the variable statically
      `x` - the value to store into the indicated Java variable
    Throws:
      `RuntimeException` - No defined exceptions are thrown, not even `NullPointerException`

  - ### getObject

    public Object getObject(Object o, long offset)
    Fetches a reference value from a given Java variable.
    See Also:
      - `getInt(Object, long)`

  - ### putObject

    public void putObject(Object o, long offset, Object x)
    Stores a reference value into a given Java variable. Unless the reference `x` being stored is either null or matches the field type, the results are undefined. If the reference `o` is non-null, car marks or other store barriers for that object (if the VM requires them) are updated.
    See Also:
      - `putInt(Object, int, int)`

  - ### getBoolean

    public boolean getBoolean(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putBoolean

    public void putBoolean(Object o, long offset, boolean x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getByte

    public byte getByte(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putByte

    public void putByte(Object o, long offset, byte x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getShort

    public short getShort(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putShort

    public void putShort(Object o, long offset, short x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getChar

    public char getChar(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putChar

    public void putChar(Object o, long offset, char x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getLong

    public long getLong(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putLong

    public void putLong(Object o, long offset, long x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getFloat

    public float getFloat(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putFloat

    public void putFloat(Object o, long offset, float x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getDouble

    public double getDouble(Object o, long offset)
    See Also:
      - `getInt(Object, long)`

  - ### putDouble

    public void putDouble(Object o, long offset, double x)
    See Also:
      - `putInt(Object, int, int)`

  - ### getInt

    @Deprecated public int getInt(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.
    This method, like all others with 32-bit offsets, was native in a previous release but is now a wrapper which simply casts the offset to a long value. It provides backward compatibility with bytecodes compiled against 1.4.

  - ### putInt

    @Deprecated public void putInt(Object o, int offset, int x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getObject

    @Deprecated public Object getObject(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putObject

    @Deprecated public void putObject(Object o, int offset, Object x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getBoolean

    @Deprecated public boolean getBoolean(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putBoolean

    @Deprecated public void putBoolean(Object o, int offset, boolean x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getByte

    @Deprecated public byte getByte(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putByte

    @Deprecated public void putByte(Object o, int offset, byte x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getShort

    @Deprecated public short getShort(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putShort

    @Deprecated public void putShort(Object o, int offset, short x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getChar

    @Deprecated public char getChar(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putChar

    @Deprecated public void putChar(Object o, int offset, char x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getLong

    @Deprecated public long getLong(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putLong

    @Deprecated public void putLong(Object o, int offset, long x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getFloat

    @Deprecated public float getFloat(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putFloat

    @Deprecated public void putFloat(Object o, int offset, float x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getDouble

    @Deprecated public double getDouble(Object o, int offset)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### putDouble

    @Deprecated public void putDouble(Object o, int offset, double x)
    Deprecated.
    As of 1.4.1, cast the 32-bit offset argument to a long. See `staticFieldOffset(java.lang.reflect.Field)`.

  - ### getByte

    public byte getByte(long address)
    Fetches a value from a given memory address. If the address is zero, or does not point into a block obtained from `allocateMemory(long)`, the results are undefined.
    See Also:
      - `allocateMemory(long)`

  - ### putByte

    public void putByte(long address, byte x)
    Stores a value into a given memory address. If the address is zero, or does not point into a block obtained from `allocateMemory(long)`, the results are undefined.
    See Also:
      - `getByte(long)`

  - ### getShort

    public short getShort(long address)
    See Also:
      - `getByte(long)`

  - ### putShort

    public void putShort(long address, short x)
    See Also:
      - `putByte(long, byte)`

  - ### getChar

    public char getChar(long address)
    See Also:
      - `getByte(long)`

  - ### putChar

    public void putChar(long address, char x)
    See Also:
      - `putByte(long, byte)`

  - ### getInt

    public int getInt(long address)
    See Also:
      - `getByte(long)`

  - ### putInt

    public void putInt(long address, int x)
    See Also:
      - `putByte(long, byte)`

  - ### getLong

    public long getLong(long address)
    See Also:
      - `getByte(long)`

  - ### putLong

    public void putLong(long address, long x)
    See Also:
      - `putByte(long, byte)`

  - ### getFloat

    public float getFloat(long address)
    See Also:
      - `getByte(long)`

  - ### putFloat

    public void putFloat(long address, float x)
    See Also:
      - `putByte(long, byte)`

  - ### getDouble

    public double getDouble(long address)
    See Also:
      - `getByte(long)`

  - ### putDouble

    public void putDouble(long address, double x)
    See Also:
      - `putByte(long, byte)`

  - ### getAddress

    public long getAddress(long address)
    Fetches a native pointer from a given memory address. If the address is zero, or does not point into a block obtained from `allocateMemory(long)`, the results are undefined. If the native pointer is less than 64 bits wide, it is extended as an unsigned number to a Java long. The pointer may be indexed by any given byte offset, simply by adding that offset (as a simple integer) to the long representing the pointer. The number of bytes actually read from the target address maybe determined by consulting `addressSize()`.
    See Also:
      - `allocateMemory(long)`

  - ### putAddress

    public void putAddress(long address, long x)
    Stores a native pointer into a given memory address. If the address is zero, or does not point into a block obtained from `allocateMemory(long)`, the results are undefined. The number of bytes actually written at the target address maybe determined by consulting `addressSize()`.
    See Also:
      - `getAddress(long)`

  - ### allocateMemory

    public long allocateMemory(long bytes)
    Allocates a new block of native memory, of the given size in bytes. The contents of the memory are uninitialized; they will generally be garbage. The resulting native pointer will never be zero, and will be aligned for all value types. Dispose of this memory by calling `freeMemory(long)`, or resize it with `reallocateMemory(long, long)`.
    Throws:
      `IllegalArgumentException` - if the size is negative or too large for the native size_t type
      `OutOfMemoryError` - if the allocation is refused by the system
    See Also:
      - `getByte(long)`
      - `putByte(long, byte)`

  - ### reallocateMemory

    public long reallocateMemory(long address, long bytes)
    Resizes a new block of native memory, to the given size in bytes. The contents of the new block past the size of the old block are uninitialized; they will generally be garbage. The resulting native pointer will be zero if and only if the requested size is zero. The resulting native pointer will be aligned for all value types. Dispose of this memory by calling `freeMemory(long)`, or resize it with `reallocateMemory(long, long)`. The address passed to this method may be null, in which case an allocation will be performed.
    Throws:
      `IllegalArgumentException` - if the size is negative or too large for the native size_t type
      `OutOfMemoryError` - if the allocation is refused by the system
    See Also:
      - `allocateMemory(long)`

  - ### setMemory

    public void setMemory(long address, long bytes, byte value)
    Sets all bytes in a given block of memory to a fixed value (usually zero).

  - ### copyMemory

    public void copyMemory(long srcAddress, long destAddress, long bytes)
    Sets all bytes in a given block of memory to a copy of another block.

  - ### freeMemory

    public void freeMemory(long address)
    Disposes of a block of native memory, as obtained from `allocateMemory(long)` or `reallocateMemory(long, long)`. The address passed to this method may be null, in which case no action is taken.
    See Also:
      - `allocateMemory(long)`

  - ### fieldOffset

    @Deprecated public int fieldOffset(Field f)
    Deprecated.
    As of 1.4.1, use `staticFieldOffset(java.lang.reflect.Field)` for static fields and `objectFieldOffset(java.lang.reflect.Field)` for non-static fields.
    Returns the offset of a field, truncated to 32 bits. This method is implemented as follows:

    >      public int fieldOffset(Field f) {
    >          if (Modifier.isStatic(f.getModifiers()))
    >              return (int) staticFieldOffset(f);
    >          else
    >              return (int) objectFieldOffset(f);
    >      }

  - ### staticFieldBase

    @Deprecated public Object staticFieldBase(Class c)
    Deprecated.
    As of 1.4.1, use `staticFieldBase(Field)` to obtain the base pertaining to a specific `Field`. This method works only for JVMs which store all statics for a given class in one place.
    Returns the base address for accessing some static field in the given class. This method is implemented as follows:

    >      public Object staticFieldBase(Class c) {
    >          Field[] fields = c.getDeclaredFields();
    >          for (int i = 0; i < fields.length; i++) {
    >              if (Modifier.isStatic(fields[i].getModifiers())) {
    >                  return staticFieldBase(fields[i]);
    >              }
    >          }
    >          return null;
    >      }

  - ### staticFieldOffset

    public long staticFieldOffset(Field f)
    Report the location of a given field in the storage allocation of its class. Do not expect to perform any sort of arithmetic on this offset; it is just a cookie which is passed to the unsafe heap memory accessors. Any given field will always have the same offset and base, and no two distinct fields of the same class will ever have the same offset and base. As of 1.4.1, offsets for fields are represented as long values, although the Sun JVM does not use the most significant 32 bits. However, JVM implementations which store static fields at absolute addresses can use long offsets and null base pointers to express the field locations in a form usable by `getInt(Object,long)`. Therefore, code which will be ported to such JVMs on 64-bit platforms must preserve all bits of static field offsets.
    See Also:
      - `getInt(Object, long)`

  - ### objectFieldOffset

    public long objectFieldOffset(Field f)
    Report the location of a given static field, in conjunction with `staticFieldBase(java.lang.Class)`. Do not expect to perform any sort of arithmetic on this offset; it is just a cookie which is passed to the unsafe heap memory accessors. Any given field will always have the same offset, and no two distinct fields of the same class will ever have the same offset. As of 1.4.1, offsets for fields are represented as long values, although the Sun JVM does not use the most significant 32 bits. It is hard to imagine a JVM technology which needs more than a few bits to encode an offset within a non-array object, However, for consistency with other methods in this class, this method reports its result as a long value.
    See Also:
      - `getInt(Object, long)`

  - ### staticFieldBase

    public Object staticFieldBase(Field f)
    Report the location of a given static field, in conjunction with `staticFieldOffset(java.lang.reflect.Field)`. Fetch the base "Object", if any, with which static fields of the given class can be accessed via methods like `getInt(Object, long)`. This value may be null. This value may refer to an object which is a "cookie", not guaranteed to be a real Object, and it should not be used in any way except as argument to the get and put routines in this class.

  - ### ensureClassInitialized

    public void ensureClassInitialized(Class c)
    Ensure the given class has been initialized. This is often needed in conjunction with obtaining the static field base of a class.

  - ### arrayBaseOffset

    public int arrayBaseOffset(Class arrayClass)
    Report the offset of the first element in the storage allocation of a given array class. If `arrayIndexScale(java.lang.Class)` returns a non-zero value for the same class, you may use that scale factor, together with this base offset, to form new offsets to access elements of arrays of the given class.
    See Also:
      - `getInt(Object, long)`
      - `putInt(Object, long, int)`

  - ### arrayIndexScale

    public int arrayIndexScale(Class arrayClass)
    Report the scale factor for addressing elements in the storage allocation of a given array class. However, arrays of "narrow" types will generally not work properly with accessors like `getByte(Object, int)`, so the scale factor for such classes is reported as zero.
    See Also:
      - `arrayBaseOffset(java.lang.Class)`
      - `getInt(Object, long)`
      - `putInt(Object, long, int)`

  - ### addressSize

    public int addressSize()
    Report the size in bytes of a native pointer, as stored via `putAddress(long, long)`. This value will be either 4 or 8. Note that the sizes of other primitive types (as stored in native memory blocks) is determined fully by their information content.

  - ### pageSize

    public int pageSize()
    Report the size in bytes of a native memory page (whatever that is). This value will always be a power of two.

  - ### defineClass

    public Class defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain)
    Tell the VM to define a class, without security checks. By default, the class loader and protection domain come from the caller's class.

  - ### defineClass

    public Class defineClass(String name, byte[] b, int off, int len)

  - ### allocateInstance

    public Object allocateInstance(Class cls) throws InstantiationException
    Allocate an instance but do not run any constructor. Initializes the class if it has not yet been.
    Throws:
      `InstantiationException`

  - ### monitorEnter

    public void monitorEnter(Object o)
    Lock the object. It must get unlocked via `monitorExit(java.lang.Object)`.

  - ### monitorExit

    public void monitorExit(Object o)
    Unlock the object. It must have been locked via `monitorEnter(java.lang.Object)`.

  - ### tryMonitorEnter

    public boolean tryMonitorEnter(Object o)
    Tries to lock the object. Returns true or false to indicate whether the lock succeeded. If it did, the object must be unlocked via `monitorExit(java.lang.Object)`.

  - ### throwException

    public void throwException(Throwable ee)
    Throw the exception without telling the verifier.

  - ### compareAndSwapObject

    public final boolean compareAndSwapObject(Object o, long offset, Object expected, Object x)
    Atomically update Java variable to `x` if it is currently holding `expected`.
    Returns:
      `true` if successful

  - ### compareAndSwapInt

    public final boolean compareAndSwapInt(Object o, long offset, int expected, int x)
    Atomically update Java variable to `x` if it is currently holding `expected`.
    Returns:
      `true` if successful

  - ### compareAndSwapLong

    public final boolean compareAndSwapLong(Object o, long offset, long expected, long x)
    Atomically update Java variable to `x` if it is currently holding `expected`.
    Returns:
      `true` if successful

  - ### getObjectVolatile

    public Object getObjectVolatile(Object o, long offset)
    Fetches a reference value from a given Java variable, with volatile load semantics. Otherwise identical to `getObject(Object, long)`

  - ### putObjectVolatile

    public void putObjectVolatile(Object o, long offset, Object x)
    Stores a reference value into a given Java variable, with volatile store semantics. Otherwise identical to `putObject(Object, long, Object)`

  - ### getIntVolatile

    public int getIntVolatile(Object o, long offset)
    Volatile version of `getInt(Object, long)`

  - ### putIntVolatile

    public void putIntVolatile(Object o, long offset, int x)
    Volatile version of `putInt(Object, long, int)`

  - ### getBooleanVolatile

    public boolean getBooleanVolatile(Object o, long offset)
    Volatile version of `getBoolean(Object, long)`

  - ### putBooleanVolatile

    public void putBooleanVolatile(Object o, long offset, boolean x)
    Volatile version of `putBoolean(Object, long, boolean)`

  - ### getByteVolatile

    public byte getByteVolatile(Object o, long offset)
    Volatile version of `getByte(Object, long)`

  - ### putByteVolatile

    public void putByteVolatile(Object o, long offset, byte x)
    Volatile version of `putByte(Object, long, byte)`

  - ### getShortVolatile

    public short getShortVolatile(Object o, long offset)
    Volatile version of `getShort(Object, long)`

  - ### putShortVolatile

    public void putShortVolatile(Object o, long offset, short x)
    Volatile version of `putShort(Object, long, short)`

  - ### getCharVolatile

    public char getCharVolatile(Object o, long offset)
    Volatile version of `getChar(Object, long)`

  - ### putCharVolatile

    public void putCharVolatile(Object o, long offset, char x)
    Volatile version of `putChar(Object, long, char)`

  - ### getLongVolatile

    public long getLongVolatile(Object o, long offset)
    Volatile version of `getLong(Object, long)`

  - ### putLongVolatile

    public void putLongVolatile(Object o, long offset, long x)
    Volatile version of `putLong(Object, long, long)`

  - ### getFloatVolatile

    public float getFloatVolatile(Object o, long offset)
    Volatile version of `getFloat(Object, long)`

  - ### putFloatVolatile

    public void putFloatVolatile(Object o, long offset, float x)
    Volatile version of `putFloat(Object, long, float)`

  - ### getDoubleVolatile

    public double getDoubleVolatile(Object o, long offset)
    Volatile version of `getDouble(Object, long)`

  - ### putDoubleVolatile

    public void putDoubleVolatile(Object o, long offset, double x)
    Volatile version of `putDouble(Object, long, double)`

  - ### putOrderedObject

    public void putOrderedObject(Object o, long offset, Object x)
    Version of `putObjectVolatile(Object, long, Object)` that does not guarantee immediate visibility of the store to other threads. This method is generally only useful if the underlying field is a Java volatile (or if an array cell, one that is otherwise only accessed using volatile accesses).

  - ### putOrderedInt

    public void putOrderedInt(Object o, long offset, int x)
    Ordered/Lazy version of `putIntVolatile(Object, long, int)`

  - ### putOrderedLong

    public void putOrderedLong(Object o, long offset, long x)
    Ordered/Lazy version of `putLongVolatile(Object, long, long)`

  - ### unpark

    public void unpark(Object thread)
    Unblock the given thread blocked on `park`, or, if it is not blocked, cause the subsequent call to `park` not to block. Note: this operation is "unsafe" solely because the caller must somehow ensure that the thread has not been destroyed. Nothing special is usually required to ensure this when called from Java (in which there will ordinarily be a live reference to the thread) but this is not nearly-automatically so when calling from native code.
    Parameters:
      `thread` - the thread to unpark.

  - ### park

    public void park(boolean isAbsolute, long time)
    Block current thread, returning when a balancing `unpark` occurs, or a balancing `unpark` has already occurred, or the thread is interrupted, or, if not absolute and time is not zero, the given time nanoseconds have elapsed, or if absolute, the given deadline in milliseconds since Epoch has passed, or spuriously (i.e., returning for no "reason"). Note: This operation is in the Unsafe class only because `unpark` is, so it would be strange to place it elsewhere.

  - ### getLoadAverage

    public int getLoadAverage(double[] loadavg, int nelems)
    Gets the load average in the system run queue assigned to the available processors averaged over various periods of time. This method retrieves the given `nelem` samples and assigns to the elements of the given `loadavg` array. The system imposes a maximum of 3 samples, representing averages over the last 1, 5, and 15 minutes, respectively.
    Returns:
      the number of samples actually retrieved; or -1 if the load average is unobtainable.