（转载）Java CAS 和 synchronized 和 Lock

原文链接：Java CAS 和 synchronized 和 Lock - CSDN博客

CAS 机制

适用场景：乐观认为并发不高，不需要阻塞，可以不上锁。 

特点：不断比较更新，直到成功。

缺点：高并发cpu压力大；ABA问题。

ABA问题： 

CAS机制生效的前提是，取出内存中某时刻的数据，而在下时刻比较并替换。 

如果在比较之前，数据发生了变化，例如：A->B->A，即A变为B然后又变化A，那么这个数据还是发生了变化，但是CAS还是会成功。

Java中CAS机制使用版本号进行对比，避免ABA问题。

synchronized

适用场景：悲观认为并发很高，需要阻塞，需要上锁。

特点：语言层面的优化，锁粗化、偏向锁、轻量锁等等；可读性高。

ReentrantLock 和 Atomic类

以上两种并发工具都使用了CAS机制。 

在并发不高竞争不激烈时候，性能略低于synchronized；相反，并发高竞争激烈时候，性能高于synchronized。

ReentrantLock相对于synchronized：

ReentrantLock等待可中断，synchronized不可以。

ReentrantLock需要手动释放锁，synchronized不需要。

ReentrantLock可支持公平非公平锁，synchronized只支持非公平锁。

ReentrantLock没有语言层面的优化，底层实现机制AQS和CAS，synchronized有优化。

ReentrantLock可重入锁，synchronized不可重入，可能导致死锁。

ReentrantLock支持读写锁，可以提高高并发读操作。

synchronized由操作系统支持，涉及内核态和用户态的上下文切换，并发高时切换开销非常大。

ReentrantLock（AQS）依赖volatile int变量标示锁状态，结构为双向链表的等待队列，通过（cas+死循环）更改锁状态，一旦更新成功，标示竞争到锁。

AQS释放锁： 

通过cas改变状态

private void doReleaseShared() {

        /*

        * Ensure that a release propagates, even if there are other

        * in-progress acquires/releases.  This proceeds in the usual

        * way of trying to unparkSuccessor of head if it needs

        * signal. But if it does not, status is set to PROPAGATE to

        * ensure that upon release, propagation continues.

        * Additionally, we must loop in case a new node is added

        * while we are doing this. Also, unlike other uses of        * unparkSuccessor, we need to know if CAS to reset status

        * fails, if so rechecking.

        */

        for (;;) {

            Node h = head;

            if (h != null && h != tail) {

                int ws = h.waitStatus;

                if (ws == Node.SIGNAL) {

                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

                        continue;            // loop to recheck cases

                    unparkSuccessor(h);

                }

                else if (ws == 0 &&

                        !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

                    continue;                // loop on failed CAS

            }

            if (h == head)                  // loop if head changed

                break;

        }

    }

获取锁： 

如果获取到锁，设为头节点，否则一直自旋等待，在高并发时，可以避免大量锁竞争的上下文切换，降低线程切换开销。

private void doAcquireInterruptibly(int arg)

        throws InterruptedException {

        final Node node = addWaiter(Node.EXCLUSIVE);

        boolean failed = true;

        try {

            for (;;) {

                final Node p = node.predecessor();

                if (p == head && tryAcquire(arg)) {

                    setHead(node);

                    p.next = null; // help GC                    failed = false;

                    return;

                }

                if (shouldParkAfterFailedAcquire(p, node) &&

                    parkAndCheckInterrupt())

                    throw new InterruptedException();

            }

        } finally {

            if (failed)

                cancelAcquire(node);

        }

    }