1, Introduction to Unsafe class
If you have seen the source code of JUC, I believe you will not be unfamiliar with the Unsafe class. The bottom core of the whole JUC is the Unsafe class. The Unsafe class is located in sun A class under misc package, which is a tool class (underlying c + + implementation) provided by jdk to directly access operating system resources. Like its name, this class is Unsafe, but it is particularly powerful.
So what kind of powerful functions does it have? Unsafe class enables Java to operate memory space like C language pointers. As we all know, compared with C and C + +, Java language makes developers do not need to pay attention to memory management during development, and these JVM s are all processed automatically. But if Java developers want to manipulate memory directly, they can use the unsafe class. Especially in the case of high concurrency, direct operation of memory can better improve efficiency.
So why is it Unsafe? Even call it Unsafe? Little friends who have studied C and C + + must know that improper operation of memory will lead to many major problems. Therefore, once the memory can be operated directly, it means that it is not managed by the JVM, which means that it cannot be GC. We need to manually GC, and memory leakage will occur if we are careless; In addition, many Unsafe methods must provide the original address (memory address) and the address of the replaced object. The offset should be calculated by yourself. Once a problem occurs, it is an exception at the JVM crash level, which will lead to the collapse of the entire JVM instance, which is manifested as the direct crash of the application. This makes Java, a highly secure language, no longer secure. Therefore, Java stipulates that the Unsafe class is only used by the Java core class library and cannot be used by ordinary users (of course, it can be obtained if you want to use it).
2, How to get Unsafe instances
Check the source code of Unsafe (Note: the source code of sun.misc package cannot be obtained from Oracle Jdk8. If you want to see the source code of this package, you can download openjdk directly)
//Class is decorated with final and cannot be inherited
public final class Unsafe {
//The construction method is privatized
private Unsafe() {}
//It indicates that Unsafe is a single case
private static final Unsafe theUnsafe = new Unsafe();
//Get Unsafe instance
@CallerSensitive
public static Unsafe getUnsafe() {
Class<?> caller = Reflection.getCallerClass();
//The non start class loader throws an exception directly
if (!VM.isSystemDomainLoader(caller.getClassLoader()))
throw new SecurityException("Unsafe");
return theUnsafe;
}
}
From the above code, we can draw the following conclusions:
- Unsafe class is final and cannot be inherited. Therefore, unsafe functions cannot be inherited through subclasses
- Construction methods are privatized, that is, objects cannot be created directly through new
- The Unsafe instance is a single instance
- Although the method of obtaining Unsafe instance is provided, it cannot be obtained in our own developed class. Calling getUnsafe() method will directly throw SecurityException exception. This is because in the getUnsafe() method of Unsafe class, it makes a layer of verification to judge whether the class loader (ClassLoader) of the current class starts the class loader (Bootstrap ClassLoader). If not, it will throw a SecurityException exception. In the JVM's class loading mechanism, the class loader used by the custom class is the Application ClassLoader, so the verification fails at this time and an exception is thrown.
Therefore, classes written by ourselves cannot directly obtain Unsafe instances through conventional methods, but we can provide other special methods. There are two options
-
The first scheme: meet its class loader detection conditions.
We can add the path of the jar package where the custom class is located to the Java command through the - Xbootclasspath parameter, so that when the program starts, the Bootstrap ClassLoader will load the Demo class, and the verification will pass. However, this method is cumbersome and not practical, because it may be necessary to use Unsafe classes in many places in the project. If it is specified through the Java command line, it will be very troublesome and prone to mistakes.
-
The second scheme: Reflection
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { Field field = Unsafe.class.getDeclaredField("theUnsafe"); // Set the access permission of the field to true field.setAccessible(true); // Because theUnsafe field is a static field in the Unsafe class, you can use field When get() gets the field value, null can be passed Unsafe unsafe = (Unsafe) field.get(null); //Print object System.out.println(unsafe); }
3, Introduction to Unsafe functions
The API s provided in the Unsafe class can be roughly divided into eight categories. The relevant methods and application scenarios of each category are described in detail below.
1. CAS operation
In Java locks, we often see CAS operations. Without exception, they eventually call CAS operations in Unsafe classes. The methods are as follows
/**
* @param o Object to operate on in memory
* @param offset The memory address offset of the value to be manipulated
* @param expected Expected value
* @param x The value you want to update to
* @return boolean true: Update succeeded false: update failed
**/
//Compare and exchange Object types
public final native boolean compareAndSwapObject(Object o, long offset,
Object expected,
Object x);
//Compare and exchange int types
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
//Compare and exchange long types
public final native boolean compareAndSwapLong(Object o, long offset,
long expected,
long x);
//int type value plus the specified number returns the original value
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
//Get value in memory
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));//Update data by spin
return v;
}
//long type value plus the specified number returns the original value
public final long getAndAddLong(Object o, long offset, long delta) {
long v;
do {
v = getLongVolatile(o, offset);
} while (!compareAndSwapLong(o, offset, v, v + delta));
return v;
}
//Set the int type value to the specified value and return the original value
public final int getAndSetInt(Object o, long offset, int newValue) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, newValue));
return v;
}
//Set the value of long type to the specified value and return the original value
public final long getAndSetLong(Object o, long offset, long newValue) {
long v;
do {
v = getLongVolatile(o, offset);
} while (!compareAndSwapLong(o, offset, v, newValue));
return v;
}
//Set the Object type value to the specified value and return the original value
public final Object getAndSetObject(Object o, long offset, Object newValue) {
Object v;
do {
v = getObjectVolatile(o, offset);
} while (!compareAndSwapObject(o, offset, v, newValue));
return v;
}
The above compareAndSwapObject, compareAndSwapInt and compareAndSwapLong are the basic methods, which are modified by native, and the bottom layer is implemented by C + +. The other methods, such as getAndAddInt, call these three basic methods to realize the correctness of data update by constantly spinning and repeatedly taking the value in memory. Unsafe is used in AQS (AbstractQueuedSynchronizer) and atomic classes, such as AtomicInteger
public class AtomicInteger extends Number implements java.io.Serializable {
//Get Unsafe class
private static final Unsafe unsafe = Unsafe.getUnsafe();
//Memory address offset of value
private static final long valueOffset;
static {
try {
//Gets the memory address offset of value
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//volatile decoration is used to ensure visibility
private volatile int value;
//Compare and update
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
}
2. Memory operation
It mainly includes the allocation, copy, release, given address value operation and other methods of off heap memory.
//Allocate memory, equivalent to malloc function of C + + public native long allocateMemory(long bytes); //Extended memory public native long reallocateMemory(long address, long bytes); //Free memory public native void freeMemory(long address); //Sets a value in a given memory block public native void setMemory(Object o, long offset, long bytes, byte value); //Memory Copy public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes); //Gets the given address value, ignoring the access restrictions of the modifier qualifier. Similar operations include: getInt, getDouble, getLong, getChar, etc public native Object getObject(Object o, long offset); //Set a value for a given address and ignore the access restrictions of the modifier qualifier. Similar operations include putInt,putDouble, putLong, putChar, etc public native void putObject(Object o, long offset, Object x); //Get the value of byte type of the given address (if and only if the memory address is allocated by allocateMemory, the result of this method is determined) public native byte getByte(long address); //Set the value of byte type for the given address (the result of this method is determined if and only if the memory address is allocated by allocateMemory) public native void putByte(long address, byte x);
It is worth mentioning that the memory directly applied for by Unsafe is off heap memory. This out of heap memory is relative to the memory of the JVM. Generally, after our application runs, the objects created are in the heap in the JVM memory. The heap memory is managed by the JVM, while the out of heap memory refers to the direct memory in the computer and is not managed by the JVM. Therefore, when using Unsafe class to apply for external memory, you should pay special attention, otherwise it is prone to memory leakage and other problems.
So why use off heap memory? The reasons are as follows
- Improvement of garbage collection pause. Because the out of heap memory is directly managed by the operating system rather than the JVM, when we use out of heap memory, we can maintain a small scale of in heap memory. So as to reduce the impact of recovery pause on the application during GC.
- Improve the performance of program I/O operations. Generally, in the process of I/O communication, there will be data copying from in heap memory to out of heap memory. It is recommended to store the temporary data that needs frequent inter memory data copying and has a short life cycle in out of heap memory
DirectByteBuffer is an important class used by Java to realize out of heap memory. It is usually used as a buffer pool in the communication process. For example, it is widely used in NIO frameworks such as Netty and MINA. The logic of DirectByteBuffer for creating, using and destroying off heap memory is implemented by the off heap memory API provided by Unsafe. The following is part of the source code of the DirectByteBuffer class
DirectByteBuffer(int cap) {
super(-1, 0, cap, cap);
boolean pa = VM.isDirectMemoryPageAligned();
int ps = Bits.pageSize();
long size = Math.max(1L, (long)cap + (pa ? ps : 0));
Bits.reserveMemory(size, cap);
long base = 0;
try {
// Call unsafe to request memory
base = unsafe.allocateMemory(size);
} catch (OutOfMemoryError x) {
Bits.unreserveMemory(size, cap);
throw x;
}
// Initialize memory
unsafe.setMemory(base, size, (byte) 0);
if (pa && (base % ps != 0)) {
// Round up to page boundary
address = base + ps - (base & (ps - 1));
} else {
address = base;
}
//Use Cleaner to free up memory
cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
att = null;
}
As a high-performance framework, Netty is characterized by * * "zero copy * *", which operates off heap memory. When operating off heap memory, it finally uses DirectByteBuffer to operate off heap memory. The source code is as follows
public class UnpooledUnsafeDirectByteBuf extends AbstractReferenceCountedByteBuf {
protected ByteBuffer allocateDirect(int initialCapacity) {
// Call allocateDirect of ByteBuffer to apply for out of heap memory and return DirectByteBuffer type
return ByteBuffer.allocateDirect(initialCapacity);
}
}
//ByteBuffer#allocateDirect
public static ByteBuffer allocateDirect(int capacity) {
//Directly return a DirectByteBuffer object
return new DirectByteBuffer(capacity);
}
3. Thread scheduling related operations
Mainly thread suspension and recovery methods.
//Unblock the thread, that is, wake up the specified thread public native void unpark(Object thread); //Blocking the current thread, isAbsolute indicates whether it is an absolute time (true indicates that ms timing will be realized; false indicates that ns timing will be realized), and time indicates that the timeout Automatic wake-up time can be set (0 indicates that it has been blocked and waiting for wake-up) public native void park(boolean isAbsolute, long time);
Java lock and AQS are implemented by calling LockSupport park() and LockSupport Unpark() implements thread blocking and wake-up, while LockSupport's park and unpark methods are actually implemented by calling Unsafe's park and unpark methods.
public class LockSupport {
// Blocking thread
public static void park() {
//Call the park method of Unsafe
UNSAFE.park(false, 0L);
}
// Wake up thread
public static void unpark(Thread thread) {
if (thread != null)
//Call the unpark method of Unsafe
UNSAFE.unpark(thread);
}
}
4. Array related operations
Get the base address of the array and the memory occupied by each element. When the two are used together, you can locate the location of each element in the array in memory.
//Returns the offset address of the first element in the array public native int arrayBaseOffset(Class<?> arrayClass); //Returns the memory size occupied by each element in the array, in bytes public native int arrayIndexScale(Class<?> arrayClass);
These two methods related to data operation have typical applications in the AtomicIntegerArray class (which can realize the atomic operation on each element in the Integer array), as shown in the source code of AtomicIntegerArray below
public class AtomicIntegerArray implements java.io.Serializable {
//Get Unsafe class
private static final Unsafe unsafe = Unsafe.getUnsafe();
//Gets the base address of the array
private static final int base = unsafe.arrayBaseOffset(int[].class);
private static final int shift;
private final int[] array;
static {
//Gets the memory size occupied by each element in the array
int scale = unsafe.arrayIndexScale(int[].class);
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
shift = 31 - Integer.numberOfLeadingZeros(scale);
}
//According to the offset of the first element in the array in memory and the size occupied by each element, calculate the offset of the ith element in the array in memory
private static long byteOffset(int i) {
return ((long) i << shift) + base;
}
}
5. Object related operations
It mainly includes operations related to object member attributes and unconventional object instantiation methods
//The memory offset of the address of the non member of this property relative to the memory public native long objectFieldOffset(Field f); //Get the value of the specified address offset of the given object. Similar operations include: getInt, getDouble, getLong, getChar, etc public native Object getObject(Object o, long offset); //The specified address offset setting value of a given object. Similar operations include putInt, putDouble, putLong, putChar, etc public native void putObject(Object o, long offset, Object x); //Get the reference of the variable from the specified offset of the object, and use the loading semantics of volatile public native Object getObjectVolatile(Object o, long offset); //Store the reference of the variable to the specified offset of the object, and use the storage semantics of volatile public native void putObjectVolatile(Object o, long offset, Object x); //The orderly and delayed version of putObjectVolatile method does not guarantee that the change of value will be seen by other threads immediately. Valid only if the field is decorated with the volatile modifier public native void putOrderedObject(Object o, long offset, Object x); //Bypass construction methods and initialization code to create objects public native Object allocateInstance(Class<?> cls) throws InstantiationException;
There are two application scenarios for object operation
-
1) General instantiation method
In essence, the way we usually use to create objects is to create objects through the new mechanism. However, a feature of the new mechanism is that when the Class only provides the constructor with parameters and does not display the declaration of the constructor without parameters, the constructor with parameters must be used for object construction, while when the constructor with parameters is used, the corresponding number of parameters must be passed to complete object instantiation. The allocateInstance() method is provided in Unsafe. This kind of instance object can be created only through the Class object, and there is no need to call its constructor, initialization code, JVM security check, etc. It suppresses modifier detection, that is, even if the constructor is private modified, it can be instantiated through this method, and the corresponding object can be created by mentioning the Class object. Because of this feature, allocateInstance is in Java Lang. invoke, Objenesis (which provides an object generation method that bypasses the Class constructor) and Gson (used in deserialization) have corresponding applications.
-
2) Get object and member memory address
In the Unsafe class, most API methods need to pass in an offset parameter, which represents the offset. If you want to directly operate the data of an address in memory, you must first find out where the data is, and you can know where the data is through offset. Therefore, this method is widely used. For example, in the AtomicInteger class, call the objectFieldOffset method to obtain the memory address offset of the attribute.
public class AtomicInteger extends Number implements java.io.Serializable { //Get Unsafe class private static final Unsafe unsafe = Unsafe.getUnsafe(); //Memory address offset of value private static final long valueOffset; static { try { //Gets the memory address offset of value valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); } catch (Exception ex) { throw new Error(ex); } } }
6. Class related operations
It mainly provides methods related to the operation of Class and its static fields, including static field memory location, Class definition, anonymous Class definition, check & ensure initialization, etc.
//Gets the memory address offset of the given static field, which is unique and fixed for the given field public native long staticFieldOffset(Field f); //Gets the object pointer of the given field in a static class public native Object staticFieldBase(Field f); //It is usually used to determine whether a class needs to be initialized when obtaining the static properties of a class (because if a class is not initialized, its static properties will not be initialized). Returns false if and only if the ensurecalassinitialized method does not take effect. public native boolean shouldBeInitialized(Class<?> c); //Checks whether the given class has been initialized. It is usually used when obtaining the static properties of a class (because if a class is not initialized, its static properties will not be initialized). public native void ensureClassInitialized(Class<?> c); //Define a class. This method will skip all security checks of the JVM. By default, ClassLoader and ProtectionDomain instances come from the caller public native Class<?> defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain); //Define an anonymous class public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
We can get the offset of the static field in memory: staticFieldOffset(), and get the object pointer of the static field: staticFieldBase(). Another important application is to implement jdk1 8. The implementation of lambda expression is realized by bytecode instruction invokedynic and VM Anonymous Class template mechanism. VM Anonymous Class template mechanism will eventually use the defineAnonymousClass() method of Unsafe class to create anonymous class (you can search for details by yourself, which will not be repeated here).
7. Memory barrier related operations
It is introduced in Java 8 to define the memory barrier (also known as memory barrier, memory barrier, barrier instruction, etc.), which is a kind of synchronous barrier instruction. It is a synchronization point in the operation of random access to memory by CPU or compiler, so that all read and write operations before this point can be executed before the operation after this point can be started), so as to avoid code reordering.
//Memory barrier that prevents the load operation from reordering. Load operations before the barrier cannot be reordered to those after the barrier, and load operations after the barrier cannot be reordered to those before the barrier public native void loadFence(); //Memory barrier to prohibit store operation reordering. Store operations before the barrier cannot be reordered behind the barrier, and store operations after the barrier cannot be reordered before the barrier public native void storeFence(); //Memory barrier, which prohibits the reordering of load and store operations public native void fullFence();
jdk1. The implementation of stampelock is based on this optimistic read-write lock.
8. System related operations
Obtain system related information
// Gets the size of the pointer in bytes. // For 64 bit systems, 8 is returned, indicating that the pointer size is 8 bytes // For 32-bit systems, 4 is returned, indicating that the pointer size is 4 bytes public native int addressSize(); // Returns the size of a memory page in bytes. How many powers of 2 must the return value be public native int pageSize();
java. The static method for calculating the number of memory pages required for the memory to be applied in the tool class Bits under NiO is to call the pageSize method in Unsafe to obtain the system memory page size and realize the subsequent calculation logic.
class Bits {
//Get Unsafe instance
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static int pageSize = -1;
static Unsafe unsafe() {
return unsafe;
}
static int pageSize() {
if (pageSize == -1)
//Call the pageSize method of unsafe to obtain the size of the memory page
pageSize = unsafe().pageSize();
return pageSize;
}
//Calculate the number of memory pages required
static int pageCount(long size) {
return (int)(size + (long)pageSize() - 1L) / pageSize();
}
}
Attachment: Unsafe class source code
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.misc;
import java.security.*;
import java.lang.reflect.*;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
/**
* 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 #getUnsafe
*/
public final class Unsafe {
private static native void registerNatives();
static {
registerNatives();
sun.reflect.Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
}
private Unsafe() {}
private static final Unsafe theUnsafe = new Unsafe();
/**
* Provides the caller with the capability of performing unsafe
* operations.
*
* <p> The returned <code>Unsafe</code> 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.
*
* <p> 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.
*
* <p> Here is a suggested idiom for using unsafe operations:
*
* <blockquote><pre>
* class MyTrustedClass {
* private static final Unsafe unsafe = Unsafe.getUnsafe();
* ...
* private long myCountAddress = ...;
* public int getCount() { return unsafe.getByte(myCountAddress); }
* }
* </pre></blockquote>
*
* (It may assist compilers to make the local variable be
* <code>final</code>.)
*
* @exception SecurityException if a security manager exists and its
* <code>checkPropertiesAccess</code> method doesn't allow
* access to the system properties.
*/
@CallerSensitive
public static Unsafe getUnsafe() {
Class<?> caller = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(caller.getClassLoader()))
throw new SecurityException("Unsafe");
return theUnsafe;
}
/// peek and poke operations
/// (compilers should optimize these to memory ops)
// These work on object fields in the Java heap.
// They will not work on elements of packed arrays.
/**
* Fetches a value from a given Java variable.
* More specifically, fetches a field or array element within the given
* object <code>o</code> at the given offset, or (if <code>o</code> is
* null) from the memory address whose numerical value is the given
* offset.
* <p>
* The results are undefined unless one of the following cases is true:
* <ul>
* <li>The offset was obtained from {@link #objectFieldOffset} on
* the {@link java.lang.reflect.Field} of some Java field and the object
* referred to by <code>o</code> is of a class compatible with that
* field's class.
*
* <li>The offset and object reference <code>o</code> (either null or
* non-null) were both obtained via {@link #staticFieldOffset}
* and {@link #staticFieldBase} (respectively) from the
* reflective {@link Field} representation of some Java field.
*
* <li>The object referred to by <code>o</code> is an array, and the offset
* is an integer of the form <code>B+N*S</code>, where <code>N</code> is
* a valid index into the array, and <code>B</code> and <code>S</code> are
* the values obtained by {@link #arrayBaseOffset} and {@link
* #arrayIndexScale} (respectively) from the array's class. The value
* referred to is the <code>N</code><em>th</em> element of the array.
*
* </ul>
* <p>
* 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.
* <p>
* This method refers to a variable by means of two parameters, and so
* it provides (in effect) a <em>double-register</em> 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 {@link #getInt(long)}, which provide (in effect) a
* <em>single-register</em> 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.
*
* @param o Java heap object in which the variable resides, if any, else
* null
* @param offset indication of where the variable resides in a Java heap
* object, if any, else a memory address locating the variable
* statically
* @return the value fetched from the indicated Java variable
* @throws RuntimeException No defined exceptions are thrown, not even
* {@link NullPointerException}
*/
public native int getInt(Object o, long offset);
/**
* Stores a value into a given Java variable.
* <p>
* The first two parameters are interpreted exactly as with
* {@link #getInt(Object, long)} to refer to a specific
* Java variable (field or array element). The given value
* is stored into that variable.
* <p>
* The variable must be of the same type as the method
* parameter <code>x</code>.
*
* @param o Java heap object in which the variable resides, if any, else
* null
* @param offset indication of where the variable resides in a Java heap
* object, if any, else a memory address locating the variable
* statically
* @param x the value to store into the indicated Java variable
* @throws RuntimeException No defined exceptions are thrown, not even
* {@link NullPointerException}
*/
public native void putInt(Object o, long offset, int x);
/**
* Fetches a reference value from a given Java variable.
* @see #getInt(Object, long)
*/
public native Object getObject(Object o, long offset);
/**
* Stores a reference value into a given Java variable.
* <p>
* Unless the reference <code>x</code> being stored is either null
* or matches the field type, the results are undefined.
* If the reference <code>o</code> is non-null, car marks or
* other store barriers for that object (if the VM requires them)
* are updated.
* @see #putInt(Object, int, int)
*/
public native void putObject(Object o, long offset, Object x);
/** @see #getInt(Object, long) */
public native boolean getBoolean(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putBoolean(Object o, long offset, boolean x);
/** @see #getInt(Object, long) */
public native byte getByte(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putByte(Object o, long offset, byte x);
/** @see #getInt(Object, long) */
public native short getShort(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putShort(Object o, long offset, short x);
/** @see #getInt(Object, long) */
public native char getChar(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putChar(Object o, long offset, char x);
/** @see #getInt(Object, long) */
public native long getLong(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putLong(Object o, long offset, long x);
/** @see #getInt(Object, long) */
public native float getFloat(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putFloat(Object o, long offset, float x);
/** @see #getInt(Object, long) */
public native double getDouble(Object o, long offset);
/** @see #putInt(Object, int, int) */
public native void putDouble(Object o, long offset, double x);
/**
* 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.
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public int getInt(Object o, int offset) {
return getInt(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putInt(Object o, int offset, int x) {
putInt(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public Object getObject(Object o, int offset) {
return getObject(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putObject(Object o, int offset, Object x) {
putObject(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public boolean getBoolean(Object o, int offset) {
return getBoolean(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putBoolean(Object o, int offset, boolean x) {
putBoolean(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public byte getByte(Object o, int offset) {
return getByte(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putByte(Object o, int offset, byte x) {
putByte(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public short getShort(Object o, int offset) {
return getShort(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putShort(Object o, int offset, short x) {
putShort(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public char getChar(Object o, int offset) {
return getChar(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putChar(Object o, int offset, char x) {
putChar(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public long getLong(Object o, int offset) {
return getLong(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putLong(Object o, int offset, long x) {
putLong(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public float getFloat(Object o, int offset) {
return getFloat(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putFloat(Object o, int offset, float x) {
putFloat(o, (long)offset, x);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public double getDouble(Object o, int offset) {
return getDouble(o, (long)offset);
}
/**
* @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
* See {@link #staticFieldOffset}.
*/
@Deprecated
public void putDouble(Object o, int offset, double x) {
putDouble(o, (long)offset, x);
}
// These work on values in the C heap.
/**
* Fetches a value from a given memory address. If the address is zero, or
* does not point into a block obtained from {@link #allocateMemory}, the
* results are undefined.
*
* @see #allocateMemory
*/
public native byte getByte(long address);
/**
* Stores a value into a given memory address. If the address is zero, or
* does not point into a block obtained from {@link #allocateMemory}, the
* results are undefined.
*
* @see #getByte(long)
*/
public native void putByte(long address, byte x);
/** @see #getByte(long) */
public native short getShort(long address);
/** @see #putByte(long, byte) */
public native void putShort(long address, short x);
/** @see #getByte(long) */
public native char getChar(long address);
/** @see #putByte(long, byte) */
public native void putChar(long address, char x);
/** @see #getByte(long) */
public native int getInt(long address);
/** @see #putByte(long, byte) */
public native void putInt(long address, int x);
/** @see #getByte(long) */
public native long getLong(long address);
/** @see #putByte(long, byte) */
public native void putLong(long address, long x);
/** @see #getByte(long) */
public native float getFloat(long address);
/** @see #putByte(long, byte) */
public native void putFloat(long address, float x);
/** @see #getByte(long) */
public native double getDouble(long address);
/** @see #putByte(long, byte) */
public native void putDouble(long address, double x);
/**
* Fetches a native pointer from a given memory address. If the address is
* zero, or does not point into a block obtained from {@link
* #allocateMemory}, the results are undefined.
*
* <p> 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 {@link
* #addressSize}.
*
* @see #allocateMemory
*/
public native long getAddress(long address);
/**
* Stores a native pointer into a given memory address. If the address is
* zero, or does not point into a block obtained from {@link
* #allocateMemory}, the results are undefined.
*
* <p> The number of bytes actually written at the target address maybe
* determined by consulting {@link #addressSize}.
*
* @see #getAddress(long)
*/
public native void putAddress(long address, long x);
/// wrappers for malloc, realloc, free:
/**
* 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 {@link
* #freeMemory}, or resize it with {@link #reallocateMemory}.
*
* @throws IllegalArgumentException if the size is negative or too large
* for the native size_t type
*
* @throws OutOfMemoryError if the allocation is refused by the system
*
* @see #getByte(long)
* @see #putByte(long, byte)
*/
public native long allocateMemory(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 {@link #freeMemory}, or resize it with {@link
* #reallocateMemory}. 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
*
* @throws OutOfMemoryError if the allocation is refused by the system
*
* @see #allocateMemory
*/
public native long reallocateMemory(long address, long bytes);
/**
* Sets all bytes in a given block of memory to a fixed value
* (usually zero).
*
* <p>This method determines a block's base address by means of two parameters,
* and so it provides (in effect) a <em>double-register</em> addressing mode,
* as discussed in {@link #getInt(Object,long)}. When the object reference is null,
* the offset supplies an absolute base address.
*
* <p>The stores are in coherent (atomic) units of a size determined
* by the address and length parameters. If the effective address and
* length are all even modulo 8, the stores take place in 'long' units.
* If the effective address and length are (resp.) even modulo 4 or 2,
* the stores take place in units of 'int' or 'short'.
*
* @since 1.7
*/
public native void setMemory(Object o, long offset, long bytes, byte value);
/**
* Sets all bytes in a given block of memory to a fixed value
* (usually zero). This provides a <em>single-register</em> addressing mode,
* as discussed in {@link #getInt(Object,long)}.
*
* <p>Equivalent to <code>setMemory(null, address, bytes, value)</code>.
*/
public void setMemory(long address, long bytes, byte value) {
setMemory(null, address, bytes, value);
}
/**
* Sets all bytes in a given block of memory to a copy of another
* block.
*
* <p>This method determines each block's base address by means of two parameters,
* and so it provides (in effect) a <em>double-register</em> addressing mode,
* as discussed in {@link #getInt(Object,long)}. When the object reference is null,
* the offset supplies an absolute base address.
*
* <p>The transfers are in coherent (atomic) units of a size determined
* by the address and length parameters. If the effective addresses and
* length are all even modulo 8, the transfer takes place in 'long' units.
* If the effective addresses and length are (resp.) even modulo 4 or 2,
* the transfer takes place in units of 'int' or 'short'.
*
* @since 1.7
*/
public native void copyMemory(Object srcBase, long srcOffset,
Object destBase, long destOffset,
long bytes);
/**
* Sets all bytes in a given block of memory to a copy of another
* block. This provides a <em>single-register</em> addressing mode,
* as discussed in {@link #getInt(Object,long)}.
*
* Equivalent to <code>copyMemory(null, srcAddress, null, destAddress, bytes)</code>.
*/
public void copyMemory(long srcAddress, long destAddress, long bytes) {
copyMemory(null, srcAddress, null, destAddress, bytes);
}
/**
* Disposes of a block of native memory, as obtained from {@link
* #allocateMemory} or {@link #reallocateMemory}. The address passed to
* this method may be null, in which case no action is taken.
*
* @see #allocateMemory
*/
public native void freeMemory(long address);
/// random queries
/**
* This constant differs from all results that will ever be returned from
* {@link #staticFieldOffset}, {@link #objectFieldOffset},
* or {@link #arrayBaseOffset}.
*/
public static final int INVALID_FIELD_OFFSET = -1;
/**
* Returns the offset of a field, truncated to 32 bits.
* This method is implemented as follows:
* <blockquote><pre>
* public int fieldOffset(Field f) {
* if (Modifier.isStatic(f.getModifiers()))
* return (int) staticFieldOffset(f);
* else
* return (int) objectFieldOffset(f);
* }
* </pre></blockquote>
* @deprecated As of 1.4.1, use {@link #staticFieldOffset} for static
* fields and {@link #objectFieldOffset} for non-static fields.
*/
@Deprecated
public int fieldOffset(Field f) {
if (Modifier.isStatic(f.getModifiers()))
return (int) staticFieldOffset(f);
else
return (int) objectFieldOffset(f);
}
/**
* Returns the base address for accessing some static field
* in the given class. This method is implemented as follows:
* <blockquote><pre>
* 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;
* }
* </pre></blockquote>
* @deprecated As of 1.4.1, use {@link #staticFieldBase(Field)}
* to obtain the base pertaining to a specific {@link Field}.
* This method works only for JVMs which store all statics
* for a given class in one place.
*/
@Deprecated
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.
*
* <p>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.
*
* <p>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 {@link #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 #getInt(Object, long)
*/
public native long staticFieldOffset(Field f);
/**
* Report the location of a given static field, in conjunction with {@link
* #staticFieldBase}.
* <p>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.
*
* <p>Any given field will always have the same offset, and no two distinct
* fields of the same class will ever have the same offset.
*
* <p>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 #getInt(Object, long)
*/
public native long objectFieldOffset(Field f);
/**
* Report the location of a given static field, in conjunction with {@link
* #staticFieldOffset}.
* <p>Fetch the base "Object", if any, with which static fields of the
* given class can be accessed via methods like {@link #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.
*/
public native Object staticFieldBase(Field f);
/**
* Detect if the given class may need to be initialized. This is often
* needed in conjunction with obtaining the static field base of a
* class.
* @return false only if a call to {@code ensureClassInitialized} would have no effect
*/
public native boolean shouldBeInitialized(Class<?> c);
/**
* Ensure the given class has been initialized. This is often
* needed in conjunction with obtaining the static field base of a
* class.
*/
public native void ensureClassInitialized(Class<?> c);
/**
* Report the offset of the first element in the storage allocation of a
* given array class. If {@link #arrayIndexScale} 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 #getInt(Object, long)
* @see #putInt(Object, long, int)
*/
public native int arrayBaseOffset(Class<?> arrayClass);
/** The value of {@code arrayBaseOffset(boolean[].class)} */
public static final int ARRAY_BOOLEAN_BASE_OFFSET
= theUnsafe.arrayBaseOffset(boolean[].class);
/** The value of {@code arrayBaseOffset(byte[].class)} */
public static final int ARRAY_BYTE_BASE_OFFSET
= theUnsafe.arrayBaseOffset(byte[].class);
/** The value of {@code arrayBaseOffset(short[].class)} */
public static final int ARRAY_SHORT_BASE_OFFSET
= theUnsafe.arrayBaseOffset(short[].class);
/** The value of {@code arrayBaseOffset(char[].class)} */
public static final int ARRAY_CHAR_BASE_OFFSET
= theUnsafe.arrayBaseOffset(char[].class);
/** The value of {@code arrayBaseOffset(int[].class)} */
public static final int ARRAY_INT_BASE_OFFSET
= theUnsafe.arrayBaseOffset(int[].class);
/** The value of {@code arrayBaseOffset(long[].class)} */
public static final int ARRAY_LONG_BASE_OFFSET
= theUnsafe.arrayBaseOffset(long[].class);
/** The value of {@code arrayBaseOffset(float[].class)} */
public static final int ARRAY_FLOAT_BASE_OFFSET
= theUnsafe.arrayBaseOffset(float[].class);
/** The value of {@code arrayBaseOffset(double[].class)} */
public static final int ARRAY_DOUBLE_BASE_OFFSET
= theUnsafe.arrayBaseOffset(double[].class);
/** The value of {@code arrayBaseOffset(Object[].class)} */
public static final int ARRAY_OBJECT_BASE_OFFSET
= theUnsafe.arrayBaseOffset(Object[].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 {@link
* #getByte(Object, int)}, so the scale factor for such classes is reported
* as zero.
*
* @see #arrayBaseOffset
* @see #getInt(Object, long)
* @see #putInt(Object, long, int)
*/
public native int arrayIndexScale(Class<?> arrayClass);
/** The value of {@code arrayIndexScale(boolean[].class)} */
public static final int ARRAY_BOOLEAN_INDEX_SCALE
= theUnsafe.arrayIndexScale(boolean[].class);
/** The value of {@code arrayIndexScale(byte[].class)} */
public static final int ARRAY_BYTE_INDEX_SCALE
= theUnsafe.arrayIndexScale(byte[].class);
/** The value of {@code arrayIndexScale(short[].class)} */
public static final int ARRAY_SHORT_INDEX_SCALE
= theUnsafe.arrayIndexScale(short[].class);
/** The value of {@code arrayIndexScale(char[].class)} */
public static final int ARRAY_CHAR_INDEX_SCALE
= theUnsafe.arrayIndexScale(char[].class);
/** The value of {@code arrayIndexScale(int[].class)} */
public static final int ARRAY_INT_INDEX_SCALE
= theUnsafe.arrayIndexScale(int[].class);
/** The value of {@code arrayIndexScale(long[].class)} */
public static final int ARRAY_LONG_INDEX_SCALE
= theUnsafe.arrayIndexScale(long[].class);
/** The value of {@code arrayIndexScale(float[].class)} */
public static final int ARRAY_FLOAT_INDEX_SCALE
= theUnsafe.arrayIndexScale(float[].class);
/** The value of {@code arrayIndexScale(double[].class)} */
public static final int ARRAY_DOUBLE_INDEX_SCALE
= theUnsafe.arrayIndexScale(double[].class);
/** The value of {@code arrayIndexScale(Object[].class)} */
public static final int ARRAY_OBJECT_INDEX_SCALE
= theUnsafe.arrayIndexScale(Object[].class);
/**
* Report the size in bytes of a native pointer, as stored via {@link
* #putAddress}. 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.
*/
public native int addressSize();
/** The value of {@code addressSize()} */
public static final int ADDRESS_SIZE = theUnsafe.addressSize();
/**
* Report the size in bytes of a native memory page (whatever that is).
* This value will always be a power of two.
*/
public native int pageSize();
/// random trusted operations from JNI:
/**
* Tell the VM to define a class, without security checks. By default, the
* class loader and protection domain come from the caller's class.
*/
public native Class<?> defineClass(String name, byte[] b, int off, int len,
ClassLoader loader,
ProtectionDomain protectionDomain);
/**
* Define a class but do not make it known to the class loader or system dictionary.
* <p>
* For each CP entry, the corresponding CP patch must either be null or have
* the a format that matches its tag:
* <ul>
* <li>Integer, Long, Float, Double: the corresponding wrapper object type from java.lang
* <li>Utf8: a string (must have suitable syntax if used as signature or name)
* <li>Class: any java.lang.Class object
* <li>String: any object (not just a java.lang.String)
* <li>InterfaceMethodRef: (NYI) a method handle to invoke on that call site's arguments
* </ul>
* @params hostClass context for linkage, access control, protection domain, and class loader
* @params data bytes of a class file
* @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
*/
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
/** Allocate an instance but do not run any constructor.
Initializes the class if it has not yet been. */
public native Object allocateInstance(Class<?> cls)
throws InstantiationException;
/** Lock the object. It must get unlocked via {@link #monitorExit}. */
@Deprecated
public native void monitorEnter(Object o);
/**
* Unlock the object. It must have been locked via {@link
* #monitorEnter}.
*/
@Deprecated
public native void monitorExit(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 {@link #monitorExit}.
*/
@Deprecated
public native boolean tryMonitorEnter(Object o);
/** Throw the exception without telling the verifier. */
public native void throwException(Throwable ee);
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapObject(Object o, long offset,
Object expected,
Object x);
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
/**
* Atomically update Java variable to <tt>x</tt> if it is currently
* holding <tt>expected</tt>.
* @return <tt>true</tt> if successful
*/
public final native boolean compareAndSwapLong(Object o, long offset,
long expected,
long x);
/**
* Fetches a reference value from a given Java variable, with volatile
* load semantics. Otherwise identical to {@link #getObject(Object, long)}
*/
public native Object getObjectVolatile(Object o, long offset);
/**
* Stores a reference value into a given Java variable, with
* volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)}
*/
public native void putObjectVolatile(Object o, long offset, Object x);
/** Volatile version of {@link #getInt(Object, long)} */
public native int getIntVolatile(Object o, long offset);
/** Volatile version of {@link #putInt(Object, long, int)} */
public native void putIntVolatile(Object o, long offset, int x);
/** Volatile version of {@link #getBoolean(Object, long)} */
public native boolean getBooleanVolatile(Object o, long offset);
/** Volatile version of {@link #putBoolean(Object, long, boolean)} */
public native void putBooleanVolatile(Object o, long offset, boolean x);
/** Volatile version of {@link #getByte(Object, long)} */
public native byte getByteVolatile(Object o, long offset);
/** Volatile version of {@link #putByte(Object, long, byte)} */
public native void putByteVolatile(Object o, long offset, byte x);
/** Volatile version of {@link #getShort(Object, long)} */
public native short getShortVolatile(Object o, long offset);
/** Volatile version of {@link #putShort(Object, long, short)} */
public native void putShortVolatile(Object o, long offset, short x);
/** Volatile version of {@link #getChar(Object, long)} */
public native char getCharVolatile(Object o, long offset);
/** Volatile version of {@link #putChar(Object, long, char)} */
public native void putCharVolatile(Object o, long offset, char x);
/** Volatile version of {@link #getLong(Object, long)} */
public native long getLongVolatile(Object o, long offset);
/** Volatile version of {@link #putLong(Object, long, long)} */
public native void putLongVolatile(Object o, long offset, long x);
/** Volatile version of {@link #getFloat(Object, long)} */
public native float getFloatVolatile(Object o, long offset);
/** Volatile version of {@link #putFloat(Object, long, float)} */
public native void putFloatVolatile(Object o, long offset, float x);
/** Volatile version of {@link #getDouble(Object, long)} */
public native double getDoubleVolatile(Object o, long offset);
/** Volatile version of {@link #putDouble(Object, long, double)} */
public native void putDoubleVolatile(Object o, long offset, double x);
/**
* Version of {@link #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).
*/
public native void putOrderedObject(Object o, long offset, Object x);
/** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)} */
public native void putOrderedInt(Object o, long offset, int x);
/** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
public native void putOrderedLong(Object o, long offset, long x);
/**
* Unblock the given thread blocked on <tt>park</tt>, or, if it is
* not blocked, cause the subsequent call to <tt>park</tt> 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.
* @param thread the thread to unpark.
*
*/
public native void unpark(Object thread);
/**
* Block current thread, returning when a balancing
* <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> 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 <tt>unpark</tt> is, so it would be strange to place it
* elsewhere.
*/
public native void park(boolean isAbsolute, long time);
/**
* 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 <tt>nelem</tt> samples and
* assigns to the elements of the given <tt>loadavg</tt> array.
* The system imposes a maximum of 3 samples, representing
* averages over the last 1, 5, and 15 minutes, respectively.
*
* @params loadavg an array of double of size nelems
* @params nelems the number of samples to be retrieved and
* must be 1 to 3.
*
* @return the number of samples actually retrieved; or -1
* if the load average is unobtainable.
*/
public native int getLoadAverage(double[] loadavg, int nelems);
// The following contain CAS-based Java implementations used on
// platforms not supporting native instructions
/**
* Atomically adds the given value to the current value of a field
* or array element within the given object <code>o</code>
* at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param delta the value to add
* @return the previous value
* @since 1.8
*/
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
/**
* Atomically adds the given value to the current value of a field
* or array element within the given object <code>o</code>
* at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param delta the value to add
* @return the previous value
* @since 1.8
*/
public final long getAndAddLong(Object o, long offset, long delta) {
long v;
do {
v = getLongVolatile(o, offset);
} while (!compareAndSwapLong(o, offset, v, v + delta));
return v;
}
/**
* Atomically exchanges the given value with the current value of
* a field or array element within the given object <code>o</code>
* at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param newValue new value
* @return the previous value
* @since 1.8
*/
public final int getAndSetInt(Object o, long offset, int newValue) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, newValue));
return v;
}
/**
* Atomically exchanges the given value with the current value of
* a field or array element within the given object <code>o</code>
* at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param newValue new value
* @return the previous value
* @since 1.8
*/
public final long getAndSetLong(Object o, long offset, long newValue) {
long v;
do {
v = getLongVolatile(o, offset);
} while (!compareAndSwapLong(o, offset, v, newValue));
return v;
}
/**
* Atomically exchanges the given reference value with the current
* reference value of a field or array element within the given
* object <code>o</code> at the given <code>offset</code>.
*
* @param o object/array to update the field/element in
* @param offset field/element offset
* @param newValue new value
* @return the previous value
* @since 1.8
*/
public final Object getAndSetObject(Object o, long offset, Object newValue) {
Object v;
do {
v = getObjectVolatile(o, offset);
} while (!compareAndSwapObject(o, offset, v, newValue));
return v;
}
/**
* Ensures lack of reordering of loads before the fence
* with loads or stores after the fence.
* @since 1.8
*/
public native void loadFence();
/**
* Ensures lack of reordering of stores before the fence
* with loads or stores after the fence.
* @since 1.8
*/
public native void storeFence();
/**
* Ensures lack of reordering of loads or stores before the fence
* with loads or stores after the fence.
* @since 1.8
*/
public native void fullFence();
/**
* Throws IllegalAccessError; for use by the VM.
* @since 1.8
*/
private static void throwIllegalAccessError() {
throw new IllegalAccessError();
}
}