<h4>1、了解Unsafe用法</h4>
翻看java.util.concurrent.atomic下面的源代码。我们知道这些类主要是封装了一些cas原子性操作：
其在java.util.concurrent、java.util.concurrent.locks两个包中被大量使用。我们先找个AtomicInteger类来分析一下：
<pre>
public class AtomicInteger extends Number implements java.io.Serializable {
private static final long serialVersionUID = 6214790243416807050L;
<h6>private static final Unsafe unsafe = Unsafe.getUnsafe();</h6>
private static final long valueOffset;
static {
try {
//定位对象的字段在内存中偏移量
valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}
public AtomicInteger() {
}
public final int get() {
return value;
}
public final void set(int newValue) {
value = newValue;
}
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
public final int getAndSet(int newValue) {
for (;;) { //循环比较，如果值没有被修改过的话就直接更新，否则循环
int current = get();
if (compareAndSet(current, newValue))
return current;
}
}
<h6>
public final boolean compareAndSet(int expect, int update) { //判断cas操作是否成功
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
</h6>
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int getAndIncrement() { //cas自增，返回原值
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return current;
}
}
public final int getAndDecrement() {//cas自减
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return current;
}
}
public final int getAndAdd(int delta) { cas相加，返回原值
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return current;
}
}
public final int incrementAndGet() { cas自增，返回新值
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
public final int decrementAndGet() { cas自减返回新值
for (;;) {
int current = get();
int next = current - 1;
if (compareAndSet(current, next))
return next;
}
}
public final int addAndGet(int delta) { cas相加，返回新值
for (;;) {
int current = get();
int next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
public String toString() {
return Integer.toString(get());
}
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
}
</pre>
我们发现里面最核心的方法是：compareAndSwapInt。其实Unsafe只提供了3个核心的cas。
compareAndSwapInt、compareAndSwapLong、compareAndSwapObject 分别对应整数、长整数、对象的cas操作，整理了一下atomic类使用cas操作情况：

Paste_Image.png

public native long reallocateMemory(long address, long bytes);

public native void setMemory(Object o, long offset, long bytes, byte value);

public void setMemory(long address, long bytes, byte value);

public native void copyMemory(Object srcBase, long srcOffset,Object destBase, long destOffset,long bytes);

public void copyMemory(long srcAddress, long destAddress, long bytes);

public native void freeMemory(long address);

public native int addressSize();

public native int pageSize();
</pre>
<b>定位对象的字段在内存中偏移量</b>
<pre>
public native long staticFieldOffset(Field f);

public native long objectFieldOffset(Field f);

public native Object staticFieldBase(Field f);

public native int arrayBaseOffset(Class arrayClass);

public static final int INVALID_FIELD_OFFSET = -1;

public static final int ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);

public static final int ARRAY_BYTE_BASE_OFFSE = theUnsafe.arrayBaseOffset(byte[].class);

public static final int ARRAY_SHORT_BASE_OFFSE = theUnsafe.arrayBaseOffset(short[].class);

public static final int ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);

public static final int ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);

public static final int ARRAY_LONG_BASE_OFFSET= theUnsafe.arrayBaseOffset(long[].class);

public static final int ARRAY_FLOAT_BASE_OFFSET= theUnsafe.arrayBaseOffset(float[].class);

public static final int ARRAY_DOUBLE_BASE_OFFSET= theUnsafe.arrayBaseOffset(double[].class);

public static final int ARRAY_OBJECT_BASE_OFFSET= theUnsafe.arrayBaseOffset(Object[].class);
</pre>
<b>cas操作：</b>
<pre>
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);
</pre>
<b>Unsafe的getUnsafe的方法是有授权限制的：</b>
<pre>
@CallerSensitive
public static Unsafe getUnsafe() {
Class cc = Reflection.getCallerClass();
if (cc.getClassLoader() != null)
throw new SecurityException("Unsafe");
return theUnsafe;
}
</pre>
正常情况下去应用Unsafe对象是会异常提示：

Paste_Image.png

define LOCK_IF_MP(mp) __asm cmp mp, 0 \

                   __asm je L0      \
                   __asm _emit 0xF0 \
                   __asm L0:

</pre>

所以Unsafe采用的是cpu级别的lock比synchronized的性能更加