AtmoicXXX 与 AtmoicXXXArray 源码分析

<dependency>
       <groupId>org.openjdk.jol</groupId>
       <artifactId>jol-core</artifactId>
       <version>0.10</version>
</dependency>

ClassLayout.parseInstance(unsafeModel).toPrintable()

|--------------------------------------------------------------------------------------------------------------|--------------------|
|                                            Object Header (96 bits)                                           |        State       |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
|                                  Mark Word (64 bits)                           |    Klass Word (32 bits)     |                    |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
| unused:25 | identity_hashcode:31 | cms_free:1 | age:4 | biased_lock:1 | lock:2 |    OOP to metadata object   |       Normal       |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
| thread:54 |       epoch:2        | cms_free:1 | age:4 | biased_lock:1 | lock:2 |    OOP to metadata object   |       Biased       |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
|                         ptr_to_lock_record                            | lock:2 |    OOP to metadata object   | Lightweight Locked |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
|                     ptr_to_heavyweight_monitor                        | lock:2 |    OOP to metadata object   | Heavyweight Locked |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|
|                                                                       | lock:2 |    OOP to metadata object   |    Marked for GC   |
|--------------------------------------------------------------------------------|-----------------------------|--------------------|

private static final Unsafe unsafe = Unsafe.getUnsafe(); // Unsafe类
private static final long valueOffset; // 偏移量
private volatile int value; // 数据  volatile类型的
 
/**
静态代码块，主要获取value属性在AtomicInteger的内存偏移量
*/
static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
public AtomicInteger(int initialValue) {
        value = initialValue;
    }
 
public AtomicInteger() {
}

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
Unsafe类：
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;
    }

public final void lazySet(int newValue) {
     unsafe.putOrderedInt(this, valueOffset, newValue);
}

As probably the last little JSR166 follow-up for Mustang, we added a "lazySet" method to the Atomic classes (AtomicInteger, AtomicReference, etc). This is a niche method that is sometimes useful when fine-tuning code using non-blocking data structures. The semantics are that the write is guaranteed not to be re-ordered with any previous write, but may be reordered with subsequent operations (or equivalently, might not be visible to other threads) until some other volatile write or synchronizing action occurs).

The main use case is for nulling out fields of nodes in non-blocking data structures solely for the sake of avoiding long-term garbage retention; it applies when it is harmless if other threads see non-null values for a while, but you'd like to ensure that structures are eventually GCable. In such cases, you can get better performance by avoiding the costs of the null volatile-write. There are a few other use cases along these lines for non-reference-based atomics as well, so the method is supported across all of the AtomicX classes.

For people who like to think of these operations in terms of machine-level barriers on common multiprocessors, lazySet provides a preceeding store-store barrier (which is either a no-op or very cheap on current platforms), but no store-load barrier (which is usually the expensive part of a volatile-write).


		private static final Unsafe unsafe = Unsafe.getUnsafe();
		/*
    第一个数组元素的偏移量，这块本质上指的是int[]对象中，对象头的大小，因为对象体肯定是在对象头之后的
    */
    private static final int base = unsafe.arrayBaseOffset(int[].class);
		/*
    数组元素本身的偏移量
    */
    private static final int shift;
		/*
    数组元素的引用
    */
    private final int[] array;
    static {
      	/*
        该方法是获取数组中每个元素的字节数
        */
        int scale = unsafe.arrayIndexScale(int[].class);
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
      	/*
        这个方法本质上获取2^x = scale,得出x的值，因为这个值在根据数组索引获取数据非常有用
        */
        shift = 31 - Integer.numberOfLeadingZeros(scale);
    }

public final boolean compareAndSet(int i, long expect, long update) {
				/*
         索引转偏移量
        */
        return compareAndSetRaw(checkedByteOffset(i), expect, update);
    }
 private boolean compareAndSetRaw(long offset, long expect, long update) {
   			/*
        还是CAS操作
        */
        return unsafe.compareAndSwapLong(array, offset, expect, update);
}
    private long checkedByteOffset(int i) {
        if (i < 0 || i >= array.length)
            throw new IndexOutOfBoundsException("index " + i);
        return byteOffset(i);
    }
		/*
         索引转偏移量，根据shift进行移位操作，得到下标i的真实偏移量
        */
    private static long byteOffset(int i) {
        return ((long) i << shift) + base;
    }