public final class Unsafe{

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

..............

}

/**

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

public native Object getObjectVolatile(Object obj, long l);

public native void putObjectVolatile(Object obj, long l, Object obj1);

public native int getIntVolatile(Object obj, long l);

public native void putIntVolatile(Object obj, long l, int i);

public native boolean getBooleanVolatile(Object obj, long l);

public native void putBooleanVolatile(Object obj, long l, boolean flag);

public native byte getByteVolatile(Object obj, long l);

public native void putByteVolatile(Object obj, long l, byte byte0);

public native short getShortVolatile(Object obj, long l);

public native void putShortVolatile(Object obj, long l, short word0);

public native char getCharVolatile(Object obj, long l);

public native void putCharVolatile(Object obj, long l, char c);

public native long getLongVolatile(Object obj, long l);

public native void putLongVolatile(Object obj, long l, long l1);

? public native float getFloatVolatile(Object obj, long l);

??? public native void putFloatVolatile(Object obj, long l, float f);

??? public native double getDoubleVolatile(Object obj, long l);

??? public native void putDoubleVolatile(Object obj, long l, double d);

public class LockSupport {

private LockSupport() {} // Cannot be instantiated.

// Hotspot implementation via intrinsics API

private static final Unsafe unsafe = Unsafe.getUnsafe();

private static final long parkBlockerOffset;

static {

try {

parkBlockerOffset = unsafe.objectFieldOffset

(java.lang.Thread.class.getDeclaredField("parkBlocker"));

} catch (Exception ex) { throw new Error(ex); }

}

private static void setBlocker(Thread t, Object arg) {

// Even though volatile, hotspot doesn't need a write barrier here.

unsafe.putObject(t, parkBlockerOffset, arg);

}

public class Thread{

?/**

???? * The argument supplied to the current call to

???? * java.util.concurrent.locks.LockSupport.park.

???? * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker

???? * Accessed using java.util.concurrent.locks.LockSupport.getBlocker

???? */

??? volatile Object parkBlocker;

}

public static void park(Object blocker) {

Thread t = Thread.currentThread();

setBlocker(t, blocker);

unsafe.park(false, 0L);

setBlocker(t, null);

}

public class Object{

public final native void wait(long timeout) throws InterruptedException;

public final native void notify();

public final native void notifyAll();

}