Unsafe

This constant differs from all results that will ever be returned from staticFieldOffset(Field), objectFieldOffset(Field), or arrayBaseOffset(Class).

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.

Allocate an instance but do not run any constructor. Initializes the class if it has not yet been.

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).

Report the offset of the first element in the storage allocation of a given array class. If arrayIndexScale(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.

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.

Atomically update Java variable to x if it is currently holding expected.

Atomically update Java variable to x if it is currently holding expected.

Atomically update Java variable to x if it is currently holding expected.

Sets all bytes in a given block of memory to a copy of another block.

Tell the VM to define a class, without security checks. By default, the class loader and protection domain come from the caller's class.

Ensure the given class has been initialized. This is often needed in conjunction with obtaining the static field base of a class.

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);
 }
 

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.

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().

Volatile version of getBoolean(Object, long)

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.

Volatile version of getByte(Object, long)

Volatile version of getChar(Object, long)

Volatile version of getDouble(Object, long)

Volatile version of getFloat(Object, long)

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(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(Field) and staticFieldBase(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(Class) and arrayIndexScale(Class) (respectively) from the array's class. The value referred to is the Nth 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.

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.

Volatile version of getInt(Object, long)

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.

Volatile version of getLong(Object, long)

Fetches a reference value from a given Java variable.

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

Volatile version of getShort(Object, long)

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); }
 }
 

Lock the object. It must get unlocked via monitorExit(Object).

Unlock the object. It must have been locked via monitorEnter(Object).

Report the location of a given static field, in conjunction with staticFieldBase(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.

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

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.

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().

Volatile version of putBoolean(Object, long, boolean)

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.

Volatile version of putByte(Object, long, byte)

Volatile version of putChar(Object, long, char)

Volatile version of putDouble(Object, long, double)

Volatile version of putFloat(Object, long, float)

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.

Volatile version of putInt(Object, long, int)

Volatile version of putLong(Object, long, long)

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.

Stores a reference value into a given Java variable, with volatile store semantics. Otherwise identical to putObject(Object, long, Object)

Ordered/Lazy version of putIntVolatile(Object, long, int)

Ordered/Lazy version of putLongVolatile(Object, long, long)

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).

Volatile version of putShort(Object, long, short)

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.

Sets all bytes in a given block of memory to a fixed value (usually zero).

Report the location of a given static field, in conjunction with staticFieldOffset(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.

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;
 }
 

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.

Throw the exception without telling the verifier.

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(Object).

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.