Java锁事之Unsafe、CAS、AQS知识点总结

public static Unsafe getUnsafe() throws Exception{
    Field field = Unsafe.class.getDeclaredField("theUnsafe");
    field.setAccessible(true);
    Unsafe unsafe = (Unsafe) field.get(null);
    return unsafe;
}

Field field = MyLock.class.getDeclaredField("state");
//获取字段在对象实例化之后的对象内偏移地址（对象头+偏移地址=字段地址）
long fieldOffsetAddress = unsafe.objectFieldOffset(field);

// 字段类型为引用类型
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
// 字段类型为int类型
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
// 字段类型为long类型
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

// exchange_value：改变值，新值
// compare_value：比较值，期望值
// dest： 内存地址
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
  int mp = os::is_MP();
  // c语言中嵌入汇编代码实现
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
    /**
     * 同步状态
     */
      private volatile int state;
    /**
     * 等待队列的头节点
     */
    private transient volatile Node head;

    /**
     * 等待队列的尾节点
     */
    private transient volatile Node tail;
  }

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    /**
     * 独占式获取到同步状态的线程
     */
    private transient Thread exclusiveOwnerThread;
}

public class ConditionObject implements Condition{
        /** 条件队列的首节点 */
        private transient Node firstWaiter;
        /** 条件队列的最后一个节点 */
        private transient Node lastWaiter;
}

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
condition.await();
condition.signal();

static final class Node {
        // 标志当前节点是共享式节点
        static final Node SHARED = new Node();
        // 标志当前节点是独占式节点
        static final Node EXCLUSIVE = null;

        // ===========  当前节点状态 ============
        // 取消
        static final int CANCELLED =  1;  
        // 等待触发    
        static final int SIGNAL    = -1;
        // 条件等待
        static final int CONDITION = -2;
        // 只能是head节点被设置
        // （到目前为止，我也没看明白它的作用是什么）
        static final int PROPAGATE = -3;
        
        // 当waitStatus为0时表示当前节点是新创建的节点，出队列的节点、队尾的节点、刚从条件队列中进入等待队列中的节点，都处于这种状态
        volatile int waitStatus;
}

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 先尝试快速入队
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 失败再调用enq方法自旋入队
        enq(node);
        return node;
    }

addWaiter(Node.SHARED)

addWaiter(Node.EXCLUSIVE)

public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            // 尝试共享式获取同步状态失败则自旋获取
            doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
        // 将当前线程包装为共享式节点放入等待队列，
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                // 如果当前节点的前驱节点是头节点，才去尝试共享式获取同步状态
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        // 获取同步状态成功，将当前节点设置为头节点，并传递tryAcquireShared返回的值
                        setHeadAndPropagate(node, r);
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                // 当前节点的前驱节点p的waitStatus为SIGNAL，
                // 则调用parkAndCheckInterrupt挂起当前线程等待被唤醒。
                // shouldParkAfterFailedAcquire如果前驱节点p的waitStatus小于等于0，则waitStatus会被设置为SIGNAL
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

private void setHeadAndPropagate(Node node, int propagate) {
        // 记录旧的头节点
        Node h = head; 
        // 设置node为新的头节点
        setHead(node);
        // tryAcquireShared获取同步状态成功返回的propagate大于0
        if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {
            // 判断当前节点的下一个节点是否是共享式节点，或者为空
            // 如果是，则调用doReleaseShared
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
}

private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                // 获取当前头节点的waitStatus
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    // cas将头节点的状态设置为0先，避免多个线程同时调用releaseShared方法(releaseShared中也调用doReleaseShared）
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;
                    // 由cas将头节点的waitStatus成功设置为0的线程
                    // 负责唤醒头节点的后继节点
                    unparkSuccessor(h);
                }
                // 如果头节点的waitStatus为0，则继续调用CAS修改头节点的waitStatus为PROPAGATE
                // 如果waitStatus不为0或者CAS失败则继续循环
                // （到现在都没能看明白作用是什么，也翻了很多资料）
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue; 
            }
            if (h == head)                   
                break;
        }
}