Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Is there a concept of "pointers" or "unsafe code" in Java?
Yesterday I was attending a talk by a CTO of a reputed European Comapny, and he told until recently he did not know that java has pointers . On confronting him he said he is absolutely sure about existance of pointers/unsafe code in java . I did google a lot after that but could't find anything similar . Any clue ?
2. Does re-putting an object into a ConcurrentHashMap cause a "happens-before" memory relation?
I'm working with existing code that has an object store in the form of a ConcurrentHashMap. Within the map are stored mutable objects, use by multiple threads. No two threads try to modify an object at once by design. My concern is regarding the visibility of the modifications between the threads. Currently the objects' code has synchronization on the "setters" (guarded by the object itself). ...
3. Inter-application communication between JAVA and C# using window messaging
I need to communicate with C# application using Window messaging from Java application. From my application I register for messages used for communicating. I am able to successfully get the window handle of the C# application and register messages. C# application responds to the messages by sending WM_COPYDATA response messages. I can get to a point where WM_COPYDATA is received. But I am not s...
4. Contigious Pages/Physical Memory in Java
My goal is to ensure that an array allocated in java is allocated across contiguous physical memory. The issue that I've run into is that the pages an array is allocated across tend not to be contiguous in physical memory, unless I allocate a really large array. My questions are: Why does a really large array ensure pages which are contiguous in physical memory? Is there any way to ensure an... 
1
  /*
2
   * Copyright 2000-2006 Sun Microsystems, Inc.  All Rights Reserved.
3
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
   *
5
   * This code is free software; you can redistribute it and/or modify it
6
   * under the terms of the GNU General Public License version 2 only, as
7
   * published by the Free Software Foundation.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun in the LICENSE file that accompanied this code.
10
  *
11
  * This code is distributed in the hope that it will be useful, but WITHOUT
12
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
  * version 2 for more details (a copy is included in the LICENSE file that
15
  * accompanied this code).
16
  *
17
  * You should have received a copy of the GNU General Public License version
18
  * 2 along with this work; if not, write to the Free Software Foundation,
19
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
  *
21
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package sun.misc;
27
 
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(s):
John R. Rose
See also:
getUnsafe()
39
 
40
 
41
 public final class Unsafe {
42
 
43
     private static native void registerNatives();
44
     static {
45
         registerNatives();
46
         sun.reflect.Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
47
     }
48
 
49
     private Unsafe() {}
50
 
51
     private static final Unsafe theUnsafe = new Unsafe();

    
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:
java.lang.SecurityException if a security manager exists and its checkPropertiesAccess method doesn't allow access to the system properties.
82
 
83
     public static Unsafe getUnsafe() {
84
         Class cc = sun.reflect.Reflection.getCallerClass(2);
85
         if (cc.getClassLoader() != null)
86
             throw new SecurityException("Unsafe");
87
         return ;
88
     }
89
 
90
     /// peek and poke operations
91
     /// (compilers should optimize these to memory ops)
92
 
93
     // These work on object fields in the Java heap.
94
     // They will not work on elements of packed arrays.
95
 
    
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:

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:
java.lang.RuntimeException No defined exceptions are thrown, not even java.lang.NullPointerException
150
    public native int getInt(Object o, long offset);

    
Stores a value into a given Java variable.

The first two parameters are interpreted exactly as with getInt(java.lang.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:
java.lang.RuntimeException No defined exceptions are thrown, not even java.lang.NullPointerException
172
    public native void putInt(Object o, long offset, int x);

    
Fetches a reference value from a given Java variable.

See also:
getInt(java.lang.Object,long)
178
    public native Object getObject(Object o, long offset);

    
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(java.lang.Object,int,int)
190
    public native void putObject(Object o, long offset, Object x);

    

See also:
getInt(java.lang.Object,long)
193
    public native boolean getBoolean(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
195
    public native void    putBoolean(Object o, long offset, boolean x);
    

See also:
getInt(java.lang.Object,long)
197
    public native byte    getByte(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
199
    public native void    putByte(Object o, long offset, byte x);
    

See also:
getInt(java.lang.Object,long)
201
    public native short   getShort(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
203
    public native void    putShort(Object o, long offset, short x);
    

See also:
getInt(java.lang.Object,long)
205
    public native char    getChar(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
207
    public native void    putChar(Object o, long offset, char x);
    

See also:
getInt(java.lang.Object,long)
209
    public native long    getLong(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
211
    public native void    putLong(Object o, long offset, long x);
    

See also:
getInt(java.lang.Object,long)
213
    public native float   getFloat(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
215
    public native void    putFloat(Object o, long offset, float x);
    

See also:
getInt(java.lang.Object,long)
217
    public native double  getDouble(Object o, long offset);
    

See also:
putInt(java.lang.Object,int,int)
219
    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 staticFieldOffset(java.lang.reflect.Field).
229
    @Deprecated
230
    public int getInt(Object o, int offset) {
231
        return getInt(o, (long)offset);
232
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
238
    @Deprecated
239
    public void putInt(Object o, int offset, int x) {
240
        putInt(o, (long)offset, x);
241
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
247
    @Deprecated
248
    public Object getObject(Object o, int offset) {
249
        return getObject(o, (long)offset);
250
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
256
    @Deprecated
257
    public void putObject(Object o, int offset, Object x) {
258
        putObject(o, (long)offset, x);
259
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
265
    @Deprecated
266
    public boolean getBoolean(Object o, int offset) {
267
        return getBoolean(o, (long)offset);
268
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
274
    @Deprecated
275
    public void putBoolean(Object o, int offset, boolean x) {
276
        putBoolean(o, (long)offset, x);
277
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
283
    @Deprecated
284
    public byte getByte(Object o, int offset) {
285
        return getByte(o, (long)offset);
286
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
292
    @Deprecated
293
    public void putByte(Object o, int offset, byte x) {
294
        putByte(o, (long)offset, x);
295
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
301
    @Deprecated
302
    public short getShort(Object o, int offset) {
303
        return getShort(o, (long)offset);
304
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
310
    @Deprecated
311
    public void putShort(Object o, int offset, short x) {
312
        putShort(o, (long)offset, x);
313
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
319
    @Deprecated
320
    public char getChar(Object o, int offset) {
321
        return getChar(o, (long)offset);
322
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
328
    @Deprecated
329
    public void putChar(Object o, int offset, char x) {
330
        putChar(o, (long)offset, x);
331
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
337
    @Deprecated
338
    public long getLong(Object o, int offset) {
339
        return getLong(o, (long)offset);
340
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
346
    @Deprecated
347
    public void putLong(Object o, int offset, long x) {
348
        putLong(o, (long)offset, x);
349
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
355
    @Deprecated
356
    public float getFloat(Object o, int offset) {
357
        return getFloat(o, (long)offset);
358
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
364
    @Deprecated
365
    public void putFloat(Object o, int offset, float x) {
366
        putFloat(o, (long)offset, x);
367
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
373
    @Deprecated
374
    public double getDouble(Object o, int offset) {
375
        return getDouble(o, (long)offset);
376
    }

    

Deprecated:
As of 1.4.1, cast the 32-bit offset argument to a long. See staticFieldOffset(java.lang.reflect.Field).
382
    @Deprecated
383
    public void putDouble(Object o, int offset, double x) {
384
        putDouble(o, (long)offset, x);
385
    }
387
    // These work on values in the C heap.
388

    
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)
396
    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 allocateMemory(long), the results are undefined.

See also:
getByte(long)
405
    public native void    putByte(long address, byte x);

    

See also:
getByte(long)
408
    public native short   getShort(long address);
    

See also:
putByte(long,byte)
410
    public native void    putShort(long address, short x);
    

See also:
getByte(long)
412
    public native char    getChar(long address);
    

See also:
putByte(long,byte)
414
    public native void    putChar(long address, char x);
    

See also:
getByte(long)
416
    public native int     getInt(long address);
    

See also:
putByte(long,byte)
418
    public native void    putInt(long address, int x);
    

See also:
getByte(long)
420
    public native long    getLong(long address);
    

See also:
putByte(long,byte)
422
    public native void    putLong(long address, long x);
    

See also:
getByte(long)
424
    public native float   getFloat(long address);
    

See also:
putByte(long,byte)
426
    public native void    putFloat(long address, float x);
    

See also:
getByte(long)
428
    public native double  getDouble(long address);
    

See also:
putByte(long,byte)
430
    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 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)
446
    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 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)
458
    public native void putAddress(long address, long x);
460
    /// wrappers for malloc, realloc, free:
461

    
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:
java.lang.IllegalArgumentException if the size is negative or too large for the native size_t type
java.lang.OutOfMemoryError if the allocation is refused by the system
See also:
getByte(long)
putByte(long,byte)
477
    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 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:
java.lang.IllegalArgumentException if the size is negative or too large for the native size_t type
java.lang.OutOfMemoryError if the allocation is refused by the system
See also:
allocateMemory(long)
496
    public native long reallocateMemory(long address, long bytes);

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

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

    
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)
518
    public native void freeMemory(long address);
520
    /// random queries
521

    
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). 
527
    public static final int INVALID_FIELD_OFFSET   = -1;

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

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.
543
    @Deprecated
544
    public int fieldOffset(Field f) {
545
        if (Modifier.isStatic(f.getModifiers()))
546
            return (int) staticFieldOffset(f);
547
        else
548
            return (int) objectFieldOffset(f);
549
    }

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

Deprecated:
As of 1.4.1, use staticFieldBase(java.lang.reflect.Field) to obtain the base pertaining to a specific java.lang.reflect.Field. This method works only for JVMs which store all statics for a given class in one place.
570
    @Deprecated
571
    public Object staticFieldBase(Class c) {
572
        Field[] fields = c.getDeclaredFields();
573
        for (int i = 0; i < fields.length; i++) {
574
            if (Modifier.isStatic(fields[i].getModifiers())) {
575
                return staticFieldBase(fields[i]);
576
            }
577
        }
578
        return null;
579
    }

    
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(java.lang.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(java.lang.Object,long)
599
    public native long staticFieldOffset(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(java.lang.Object,long)
618
    public native long objectFieldOffset(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(java.lang.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. 

630
    public native Object staticFieldBase(Field f);

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

    
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(java.lang.Object,long)
putInt(java.lang.Object,long,int)
649
    public native int arrayBaseOffset(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(java.lang.Object,int), so the scale factor for such classes is reported as zero.

See also:
arrayBaseOffset(java.lang.Class)
getInt(java.lang.Object,long)
putInt(java.lang.Object,long,int)
662
    public native int arrayIndexScale(Class arrayClass);

    
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. 
670
    public native int addressSize();

    
Report the size in bytes of a native memory page (whatever that is). This value will always be a power of two. 
676
    public native int pageSize();
679
    /// random trusted operations from JNI:
680

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

    
Allocate an instance but do not run any constructor. Initializes the class if it has not yet been.
693
    public native Object allocateInstance(Class cls)
694
        throws InstantiationException;

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

    
Unlock the object. It must have been locked via monitorEnter(java.lang.Object). 
703
    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 monitorExit(java.lang.Object). 
710
    public native boolean tryMonitorEnter(Object o);

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


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

Returns:
true if successful
721
    public final native boolean compareAndSwapObject(Object o, long offset,
722
                                                     Object expected,
723
                                                     Object x);

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

Returns:
true if successful
730
    public final native boolean compareAndSwapInt(Object o, long offset,
731
                                                  int expected,
732
                                                  int x);

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

Returns:
true if successful
739
    public final native boolean compareAndSwapLong(Object o, long offset,
740
                                                   long expected,
741
                                                   long x);

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

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

    
Volatile version of getInt(java.lang.Object,long) 
756
    public native int     getIntVolatile(Object o, long offset);

    
Volatile version of putInt(java.lang.Object,long,int) 
759
    public native void    putIntVolatile(Object o, long offset, int x);

    
Volatile version of getBoolean(java.lang.Object,long) 
762
    public native boolean getBooleanVolatile(Object o, long offset);

    
Volatile version of putBoolean(java.lang.Object,long,boolean) 
765
    public native void    putBooleanVolatile(Object o, long offset, boolean x);

    
Volatile version of getByte(java.lang.Object,long) 
768
    public native byte    getByteVolatile(Object o, long offset);

    
Volatile version of putByte(java.lang.Object,long,byte) 
771
    public native void    putByteVolatile(Object o, long offset, byte x);

    
Volatile version of getShort(java.lang.Object,long) 
774
    public native short   getShortVolatile(Object o, long offset);

    
Volatile version of putShort(java.lang.Object,long,short) 
777
    public native void    putShortVolatile(Object o, long offset, short x);

    
Volatile version of getChar(java.lang.Object,long) 
780
    public native char    getCharVolatile(Object o, long offset);

    
Volatile version of putChar(java.lang.Object,long,char) 
783
    public native void    putCharVolatile(Object o, long offset, char x);

    
Volatile version of getLong(java.lang.Object,long) 
786
    public native long    getLongVolatile(Object o, long offset);

    
Volatile version of putLong(java.lang.Object,long,long) 
789
    public native void    putLongVolatile(Object o, long offset, long x);

    
Volatile version of getFloat(java.lang.Object,long) 
792
    public native float   getFloatVolatile(Object o, long offset);

    
Volatile version of putFloat(java.lang.Object,long,float) 
795
    public native void    putFloatVolatile(Object o, long offset, float x);

    
Volatile version of getDouble(java.lang.Object,long) 
798
    public native double  getDoubleVolatile(Object o, long offset);

    
Volatile version of putDouble(java.lang.Object,long,double) 
801
    public native void    putDoubleVolatile(Object o, long offset, double x);

    
Version of putObjectVolatile(java.lang.Object,long,java.lang.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). 
810
    public native void    putOrderedObject(Object o, long offset, Object x);

    
Ordered/Lazy version of putIntVolatile(java.lang.Object,long,int) 
813
    public native void    putOrderedInt(Object o, long offset, int x);

    
Ordered/Lazy version of putLongVolatile(java.lang.Object,long,long)
816
    public native void    putOrderedLong(Object o, long offset, long x);

    
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.
830
    public native void unpark(Object thread);

    
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. 
843
    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 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.
Params:
loadavg an array of double of size nelems
Params:
nelems the number of samples to be retrieved and must be 1 to 3.
860
    public native int getLoadAverage(double[] loadavg, int nelems);
New to GrepCode? Check out our FAQ X