源码：
http://www.docjar.com/html/api/sun/misc/Unsafe.java.html
API文档：
http://www.docjar.com/docs/api/sun/misc/Unsafe.html

我的分类：

1.声明
2.内存的操作
3.类相关操作
4.synchronization
5.park,unpark
6.CAS

其它人的idea:
https://www.cnblogs.com/mickole/articles/3757278.html

1.首先，unsafe 类，可以分配内存，可以释放内存。
2.可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的；
3.挂起与恢复
4.CAS操作

声明

first we come to the declaration of the Usafe:
you can see the function in line 83,it will check the classLoader of the class who call it, if the one who call it have class loader ,it will throw "SecurityException". and that is the way it define if it is trusted code or not ,which annotated in the line 35.

the following passage have nice explain in " how to get the unsafe".
http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

/**
   33    * A collection of methods for performing low-level, unsafe operations.
   34    * Although the class and all methods are public, use of this class is
   35    * limited because only trusted code can obtain instances of it.
   36    *
   37    * @author John R. Rose
   38    * @see #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();
   52   
   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 theUnsafe;
   88       }

memory control

61 function explain here,the idea is all write in the annotation,include:
1.allocateMemory, reallocateMemory, freeMemory
2.get and put function
3.setMemory , copyMemory

import java.lang.reflect.Field;
import java.util.Arrays;
import sun.misc.Unsafe;

public class Test {
    private static int byteArrayBaseOffset;

    public static void main(String[] args) throws SecurityException,
            NoSuchFieldException, IllegalArgumentException,
            IllegalAccessException {
        /***
         * here shows how can we get the unsafe
         */
        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe UNSAFE = (Unsafe) theUnsafe.get(null);
        System.out.println(UNSAFE);

        /** in jdk8 there is 115 function, i count it myself ,i don't make sure i have't mistake here */

        Field sa = Integer.class.getDeclaredField("SIZE");
        System.out.println();
        long offset = UNSAFE.staticFieldOffset(sa);
        int value = UNSAFE.getInt(UNSAFE.staticFieldBase(sa),offset);
        System.out.println("value :" +value);


        /**
         * allocateMemory    allocate a new memory
         * reallocateMemory  will resize the memory size, if it fail to resize , throws OutOfMemoryError
         * freeMemory
         *
         * */


        /** in this case is show how can we use the given memory address to put value in ,and the influence in the memory
         *
         * 1.as you can see ,even you just have be allocate 1 memory ,you can use more memory ,but it is not safe at all ,
         * cause you can not forbid other thread or Object not to use the un-authority space,it will cause unexpected result
         *
         * so you know all the putXXX(long address,XXX value) and getXXX(long address) is couple
         * and how to use it.
         *
         * there are Int,Long,Byte,Boolean,Object,Float,Double,Short,Char  9  base type ,so there is 9 base function couple. 9*2=18
         *
         * there a
         *
         * */
        long am = UNSAFE.allocateMemory(1);//here i allocate a new memory
        UNSAFE.putInt(am,1);//i put a 0000 0001  in the first byte.
        System.out.println(UNSAFE.getInt(am)); //
        UNSAFE.putInt(am+1,2);//i put 0000 0010 int the second byte
        System.out.println("am+1 : "+UNSAFE.getInt(am+1)); // get the am+1 ,so it start from the second byte ,so the  output here is 2
        System.out.println("am+2 : "+ UNSAFE.getInt(am+2));//and here should be 0
        System.out.println("am :" + UNSAFE.getInt(am));// but if i start from the first byte it should be  0000 0001 0000 0010 so the result is 2*256 + 1= 512 +1 = 513,so the out put here should be 513

        UNSAFE.putInt(am+2,3);
        System.out.println(UNSAFE.getByte(am));
        System.out.println(UNSAFE.getByte(am+1));
        System.out.println(UNSAFE.getByte(am+2));
        System.out.println(UNSAFE.getByte(am+3));
        System.out.println(UNSAFE.getInt(am)); //65536 * 3 + 2*256 +1 = 196608 + 512 +1 = 197121

        UNSAFE.putInt(am+5,1);
        System.out.println(UNSAFE.getByte(am));
        System.out.println(UNSAFE.getByte(am+1));
        System.out.println(UNSAFE.getByte(am+2));
        System.out.println(UNSAFE.getByte(am+3));
        System.out.println(UNSAFE.getByte(am+4));
        System.out.println(UNSAFE.getInt(am));//so in here we can know the int take 4 bytes

        UNSAFE.freeMemory(am);
        /** like the case above,this case is almost the same. the only different is it use relative offset to describe the address
         *
         * use  object + offset to define a unique address
         *
         *  the follow case shows how it use.
         *  the same way , there are 9 base type ,so there is 9 base function couple, 9 * 2 = 18
         * */
        Integer integer = new Integer(10);
        System.out.println(integer);
        Field valueField = Integer.class.getDeclaredField("value");
        long a = UNSAFE.objectFieldOffset(valueField);
        UNSAFE.putInt(integer,a,11);
        System.out.println(UNSAFE.getInt(integer,a));
        System.out.println(integer);

        byte[] data = new byte[10];
        System.out.println(Arrays.toString(data));
        byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class);
        System.out.println(byteArrayBaseOffset);
        UNSAFE.putByte(data, byteArrayBaseOffset, (byte) 1);
        UNSAFE.putByte(data, byteArrayBaseOffset + 5, (byte) 5);
        System.out.println(Arrays.toString(data));

        /**
         * ofcourse there also provide funciton volatile
         *
         * 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);
         *
         * the same way , there are 9 base type ,so there is 9 base function couple, 9 * 2 = 18
         */

        /**
         * there is another 2 interesting function which is use to set value in batch
         *
         public native void setMemory(Object o, long offset, long bytes, byte value);
         public native void setMemory(long address, long bytes, byte value);

         * use  o + offset or address to define the unique address "start postion"
         * and bytes and value ,means from the  "start postion" to "start postion"+bytes all the byte is set the value
         *
         * byte a = new byte[10];  or int[] a = new int[2];  can be realized by this function
         *
         *
         public native void copyMemory(Object srcBase, long srcOffset,
         Object destBase, long destOffset,
         long bytes);

         public void copyMemory(long srcAddress, long destAddress, long bytes) {
         copyMemory(null, srcAddress, null, destAddress, bytes);
         }
         *
         *  so there is alse function like that
         *  use  Base + offset or address to define the unique address "start postion" ."dest position" and copy the bytes long
         *  to the dest position
         * */
        /**
         *
         * util here we have kill 3 + 18*3 + 4 = 61 function
         * */
    }
}

appedency：
reference: http://www.jdon.com/performance/java-performance-optimizations-queue.html

使用Unsafe.putOrderedObject方法，这个方法在对低延迟代码是很有用的，它能够实现非堵塞的写入，这些写入不会被Java的JIT重新排序指令([instruction reordering](http://stackoverflow.com/questions/14321212/java-instruction-reordering-cache-in-threads))，
这样它使用快速的存储-存储(store-store) barrier, 
而不是较慢的存储-加载(store-load) barrier, (用在volatile的写操作上)
这种性能提升是有代价的，虽然便宜，也就是写后结果并不会被其他线程看到，甚至是自己的线程，通常是几纳秒后被其他线程看到，这个时间比较短，所以代价可以忍受。

类似Unsafe.putOrderedObject还有unsafe.putOrderedLong等方法，unsafe.putOrderedLong比使用 volatile long要快3倍左右。.

class

  804       /**
  805        * Tell the VM to define a class, without security checks.  By default, the
  806        * class loader and protection domain come from the caller's class.
  807        */
  808       public native Class defineClass(String name, byte[] b, int off, int len,
  809                                       ClassLoader loader,
  810                                       ProtectionDomain protectionDomain);
  811   
  812       public native Class defineClass(String name, byte[] b, int off, int len);
  813   
  814       /**
  815        * Define a class but do not make it known to the class loader or system dictionary.
  816        * <p>
  817        * For each CP entry, the corresponding CP patch must either be null or have
  818        * the a format that matches its tag:
  819        * <ul>
  820        * <li>Integer, Long, Float, Double: the corresponding wrapper object type from java.lang
  821        * <li>Utf8: a string (must have suitable syntax if used as signature or name)
  822        * <li>Class: any java.lang.Class object
  823        * <li>String: any object (not just a java.lang.String)
  824        * <li>InterfaceMethodRef: (NYI) a method handle to invoke on that call site's arguments
  825        * </ul>
  826        * @params hostClass context for linkage, access control, protection domain, and class loader
  827        * @params data      bytes of a class file
  828        * @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
  829        */
  830       public native Class defineAnonymousClass(Class hostClass, byte[] data, Object[] cpPatches);

            public native Object allocateInstance(Class cls) throws InstantiationException;

synchronization

  838       /** Lock the object.  It must get unlocked via {@link #monitorExit}. */
  839       public native void monitorEnter(Object o);
  840   
  841       /**
  842        * Unlock the object.  It must have been locked via {@link
  843        * #monitorEnter}.
  844        */
  845       public native void monitorExit(Object o);
  846   
  847       /**
  848        * Tries to lock the object.  Returns true or false to indicate
  849        * whether the lock succeeded.  If it did, the object must be
  850        * unlocked via {@link #monitorExit}.
  851        */
  852       public native boolean tryMonitorEnter(Object o);
  853   
  854       /** Throw the exception without telling the verifier. */
  855       public native void throwException(Throwable ee);

thread park unpark

  960       /**
  961        * Unblock the given thread blocked on <tt>park</tt>, or, if it is
  962        * not blocked, cause the subsequent call to <tt>park</tt> not to
  963        * block.  Note: this operation is "unsafe" solely because the
  964        * caller must somehow ensure that the thread has not been
  965        * destroyed. Nothing special is usually required to ensure this
  966        * when called from Java (in which there will ordinarily be a live
  967        * reference to the thread) but this is not nearly-automatically
  968        * so when calling from native code.
  969        * @param thread the thread to unpark.
  970        *
  971        */
  972       public native void unpark(Object thread);
  973   
  974       /**
  975        * Block current thread, returning when a balancing
  976        * <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
  977        * already occurred, or the thread is interrupted, or, if not
  978        * absolute and time is not zero, the given time nanoseconds have
  979        * elapsed, or if absolute, the given deadline in milliseconds
  980        * since Epoch has passed, or spuriously (i.e., returning for no
  981        * "reason"). Note: This operation is in the Unsafe class only
  982        * because <tt>unpark</tt> is, so it would be strange to place it
  983        * elsewhere.
  984        */
  985       public native void park(boolean isAbsolute, long time);
  986   

CAS

  859        /* Atomically update Java variable to <tt>x</tt> if it is currently holding <tt>expected</tt>. 
              @return <tt>true</tt> if successful*/
  863       public final native boolean compareAndSwapObject(Object o, long offset,
  864                                                        Object expected,
  865                                                        Object x);

  872       public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

  881       public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

import java.lang.reflect.Field;
import sun.misc.Unsafe;


public class Test {
    private static Unsafe unsafe;

    public static void main(String[] args) throws Exception {
        try {
            //通过反射获取rt.jar下的Unsafe类
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);

            Integer target = 12;
            Field field1 = Integer.class.getDeclaredField("value");

            //compareAndSwapInt方法的属性分别是：目标对象实例，目标对象属性偏移量，当前预期值，要设的值.
            //compareAndSwapInt方法是通过反射修改对象的值，具体修改对象下面那个值，可以通过偏移量，对象字段的偏移量可以通过objectFieldOffset获取
            System.out.println(unsafe.compareAndSwapInt(target, unsafe.objectFieldOffset(field1), 1, 10));
            System.out.println(target);
            System.out.println(unsafe.compareAndSwapInt(target, unsafe.objectFieldOffset(field1), 12, 10));
            System.out.println(target);
        } catch (Exception e) {
            System.out.println("Get Unsafe instance occur error" + e);
        }
    }
}