Java中的锁包括synchronized锁和lock锁。他们都能保证锁的内存语义正确的实现,但是他们的底层原理却是不一样的，Lock锁的底层是使用volatile和CAS的内存语义来实现锁的内存语义的，而synchronized用的锁是存在java对象头里的，是基于JVM的支持来实现的。

1 锁的内存语义

锁是Java并发编程中最重要的同步机制。锁除了让临界区互斥执行外，还可以让释放锁的线程向获取同一个锁的线程发送消息。

语义：
当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。锁释放与volatile写具有相同的内存语义。
当线程获取锁时，JMM 会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码必须要从主内存中去读取共享变量。锁获取与volatile读具有相同的内存语义。

锁释放和锁获取的内存语义总结：
线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。
线程B获取一个锁，实质上是线程B接收了之前某个线程发出的（在释放这个锁之前对共享变量所做修改的）消息。
线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息。

2 Lock锁内存语义的实现

以ReentrantLock为例，在ReentrantLock中，调用lock()方法获取锁；调用unlock()方法释放锁。
ReentrantLock的实现依赖于Java同步器框架AbstractQueuedSynchronizer（本文简称之为AQS）。AQS使用一个整型的volatile变量（命名为state）来维护同步状态,这个volatile变量是ReentrantLock内存语义实现的关键。
ReentrantLock分为公平锁和非公平锁.我们首先分析公平锁。
使用公平锁时，加锁方法lock()调用轨迹如下：

ReentrantLock:lock()

FairSync:lock()

AbstractQueuedSynchronizer:acquire(int arg)

FairSync:tryAcquire(int acquires)

在第4步真正开始加锁，下面是该方法的部分源代码：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 获取锁的开始，首先读volatile变量state
    int c = getState();
     //..............

从上面源代码中我们可以看出，加锁方法首先读volatile变量state。
在使用公平锁时，解锁方法unlock()调用轨迹如下：

ReentrantLock:unlock()

AbstractQueuedSynchronizer:release(intarg)

Sync:tryRelease(int releases)

在第3步真正开始释放锁，下面是该方法的部分源代码：

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 释放锁的最后，写volatile变量state
    setState(c);　　　　　
    return free;
}

从上面的源代码可以看出，在释放锁的最后写volatile变量state。
公平锁在释放锁的最后写volatile变量state，在获取锁时首先读这个volatile变量。根据volatile的happens-before规则，释放锁的线程在写volatile变量之前可见的共享变量，在获取锁的线程读取同一个volatile变量后将立即变得对获取锁的线程可见。
现在我们来分析非公平锁的内存语义的实现。非公平锁的释放和公平锁完全一样，所以这里仅仅分析非公平锁的获取。使用非公平锁时，加锁方法lock()调用轨迹如下：

ReentrantLock:lock()

NonfairSync:lock()

AbstractQueuedSynchronizer:compareAndSetState(int expect,int update)

在第3步真正开始加锁，下面是该方法的源代码：

protected final boolean compareAndSetState(int expect, int 
update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

该方法以原子操作的方式更新state变量， Java的compareAndSet()方法调用简称为CAS。JDK文档对该方法的说明如下：**如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值。****此操作具有volatile读和写的内存语义。**这里我们分别从编译器和处理器的角度来分析，CAS如何同时具有volatile读和volatile写的内存语义。

2.1 CAS语义编译器实现

编译器不会对volatile读与volatile读后面的任意内存操作重排序；编译器不会对volatile写与volatile写前面的任意内存操作重排序。组合这两个条件，意味着为了同时实现volatile读和volatile写的内存语义，编译器不能对CAS与CAS前面和后面的任意内存操作重排序。

2.2 CAS语义处理器实现

与volatile一样，处理器会在cas方法指令前自动加上lock前缀指令，lock前缀指令可以

确保对内存的读-改-写操作原子执行。在Pentium及Pentium之前的处理器中，带有lock前缀的指令在执行期间会锁住总线，使得其他处理器暂时无法通过总线访问内存。很显然，这会带来昂贵的开销。从PentiumIntel Xeon及P6处理器开始，Intel使用缓存锁定（Cache Locking）来保证指令执行的原子性。缓存锁定将大大降低lock前缀指令的执行开销。
禁止该指令与之前和之后的读和写指令重排序。
把写缓冲区中的所有数据刷新到内存中。

上面的第2点和第3点所具有的内存屏障效果，足以同时实现volatile读和volatile写的内存语义。

2.3 Lock锁总结

现在对公平锁和非公平锁的内存语义做个总结。

公平锁和非公平锁释放时，最后都要写一个volatile变量state。

公平锁获取时，首先会去读volatile变量。

非公平锁获取时，首先会用CAS更新volatile变量，这个操作同时具有volatile读和volatile写的内存语义。

从上面对ReentrantLock的分析可以看出，锁释放-获取的内存语义的实现至少有下面两种方式。

利用volatile变量的写-读所具有的内存语义。

利用CAS所附带的volatile读和volatile写的内存语义。

3 concurrent包实现的基石

由于Java的CAS同时具有volatile读和volatile写的内存语义，因此Java线程之间的通信现在有了下面4种方式。

A线程写volatile变量，随后B线程读这个volatile变量。

A线程写volatile变量，随后B线程用CAS更新这个volatile变量。

A线程用CAS更新一个volatile变量，随后B线程用CAS更新这个volatile变量。

A线程用CAS更新一个volatile变量，随后B线程读这个volatile变量。

Java的CAS会使用现代处理器上提供的高效机器级别的原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键。
同时，volatile变量的读/写和CAS可以实现线程之间的通信。把CAS和volatile的这些特性整合在一起，就形成了整个concurrent包得以实现的基石。 如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的实现模式：

1、首先，声明共享变量为volatile；
2、然后，使用CAS的原子条件更新来实现线程之间的同步；
3、同时，配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的通信。

补充： AQS，非阻塞数据结构和原子变量类（java.util.concurrent.atomic 包中的类），这些 concurrent 包中的基础类都是使用这种模式来实现的，而 concurrent 包中的高层类又是依赖于这些基础类来实现的。
从整体来看，concurrent 包的实现示意图如下：
在这里插入图片描述