锁的内存语义

迈不过友情╰ 2024-03-17 11:28 10阅读 0赞

<table> 
 <thead> 
  <tr> 
   <th align="left">众所周知，锁可以让临界区<code>互斥执行</code>。这里将介绍锁的另一个同样重要，但常常被忽视的功能：锁的<code>内存语义</code>。</th> 
  </tr> 
 </thead> 
</table>

###  锁的释放-获取建立的happens-before关系  ###

<table> 
 <thead> 
  <tr> 
   <th align="left">锁是Java并发编程中最重要的同步机制。锁除了让临界区<code>互斥</code>执行外，还可以让释放锁的线程向获取同一个锁的线程<code>发送消息</code>。</th> 
  </tr> 
 </thead> 
</table>

class MonitorExample {
        
        int a = 0;
        public synchronized void writer() {
        　　　　 // 1
            a++;　　　　　　　　　　                // 2
        }　　　　　　　　　　　　                   // 3
        public synchronized void reader() {
        　　　   // 4
            int i = a;　　　　　　　　              // 5
            ……
        }　　　　　　　　　　　　                   // 6
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">假设线程A执行writer()方法，<code>随后</code>线程B执行reader()方法。根据happens-before规则，这个过程包含的happens-before关系可以分为3类。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）根据程序次序规则，1 happens-before 2,2 happens-before 3;4 happens-before 5,5 happens-before 6。</td> 
  </tr> 
  <tr> 
   <td align="left">2）根据监视器锁规则，3 happens-before 4。 （<strong>个人理解：先释放锁再加锁</strong>）</td> 
  </tr> 
  <tr> 
   <td align="left">3）根据happens-before的传递性，2 happens-before 5。</td> 
  </tr> 
 </tbody> 
</table>

###  锁的释放和获取的内存语义  ###

<table> 
 <thead> 
  <tr> 
   <th align="left">锁的释放和获取的内存语义</th> 
   <th align="left">类比volatile</th> 
   <th align="left">对锁释放和锁获取的内存语义做个总结</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">当线程<code>释放锁</code>时，JMM会把该线程对应的本地内存中的共享变量<code>刷新</code>到主内存中。</td> 
   <td align="left">锁释放与 <strong><code>volatile写</code></strong> 有相同的内存语义</td> 
   <td align="left">线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A对共享变量所做修改的）消息。</td> 
  </tr> 
  <tr> 
   <td align="left">当线程<code>获取锁</code>时，JMM会把该线程对应的本地内存<code>置为无效</code>。从而使得被监视器保护的临界区代码必须从主内存中<code>读取</code>共享变量。</td> 
   <td align="left">锁获取与 <strong><code>volatile读</code></strong> 有相同的内存语义</td> 
   <td align="left">线程B获取一个锁，实质上是线程B接收了之前某个线程发出的（在释放这个锁之前对共享变量所做修改的）消息</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
   <td align="left">线程A释放锁，随后线程B获取这个锁，这个过程实质上是线程A通过主内存向线程B发送消息</td> 
  </tr> 
 </tbody> 
</table>

###  锁内存语义的实现  ###

<table> 
 <thead> 
  <tr> 
   <th align="left">本文将借助ReentrantLock的源代码，来分析锁内存语义的具体实现机制。</th> 
  </tr> 
 </thead> 
</table>

class ReentrantLockExample {
        
        int a = 0;
        ReentrantLock lock = new ReentrantLock();
        public void writer() {
        
            lock.lock();　　　　   // 获取锁
            try {
        
                a++;
            } finally {
        
                lock.unlock();　　// 释放锁
            }
        }
        public void reader () {
        
            lock.lock();　　　　  // 获取锁
            try {
        
                int i = a;
                ……
            } finally {
        
                lock.unlock();　 // 释放锁
            }
        }
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">ReentrantLock的实现依赖于 <strong><code>Java同步器框架AbstractQueuedSynchronizer（本文简称之为AQS）</code></strong> 。AQS使用一个整型的volatile变量（命名为state）来维护同步状态，马上我们会看到，这个volatile变量是ReentrantLock内存语义实现的关键。如下是ReentrantLock的类图</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/951698c05c024e0a9d2c93c56c0b3288.png#pic_center" alt="在这里插入图片描述"></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>使用<code>公平锁</code>时，加锁方法<code>lock()</code>调用轨迹如下</strong></th> 
   <th align="left"><strong>使用<code>非公平锁</code>时，加锁方法lock()调用轨迹如下</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）ReentrantLock:lock()。</td> 
   <td align="left">1）ReentrantLock:lock()。</td> 
  </tr> 
  <tr> 
   <td align="left">2）<code>FairSync</code>:lock()。</td> 
   <td align="left">2）<code>NonfairSync</code>:lock()。</td> 
  </tr> 
  <tr> 
   <td align="left">3）AbstractQueuedSynchronizer:acquire(int arg)。</td> 
   <td align="left">3）AbstractQueuedSynchronizer:compareAndSetState(int expect,int update)。(真正开始加锁)</td> 
  </tr> 
  <tr> 
   <td align="left">4）ReentrantLock:tryAcquire(int acquires)。(真正开始加锁)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><strong>在使用公平锁时，解锁方法<code>unlock()</code>调用轨迹如下</strong></td> 
   <td align="left"><strong>非公平锁的释放和公平锁完全一样</strong></td> 
  </tr> 
  <tr> 
   <td align="left">1）ReentrantLock:unlock()。</td> 
   <td align="left">1）ReentrantLock:unlock()。</td> 
  </tr> 
  <tr> 
   <td align="left">2）AbstractQueuedSynchronizer:release(int arg)。</td> 
   <td align="left">2）AbstractQueuedSynchronizer:release(int arg)。</td> 
  </tr> 
  <tr> 
   <td align="left">3）Sync:tryRelease(int releases)。</td> 
   <td align="left">3）Sync:tryRelease(int releases)。</td> 
  </tr> 
 </tbody> 
</table>

protected final boolean tryAcquire(int acquires) {
        
        final Thread current = Thread.currentThread();
        int c = getState();　　　　// 获取锁的开始，首先读volatile变量state
        if (c == 0) {
        
            if (isFirst(current) && compareAndSetState(0, acquires)) {
        
                    setExclusiveOwnerThread(current);
                    return true;
                }
        } else if (current == getExclusiveOwnerThread()) {
        
            int nextc = c + acquires;
            if (nextc < 0)　　
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">从上面源代码中我们可以看出，加锁方法首先<code>读</code>volatile变量state。</th> 
  </tr> 
 </thead> 
</table>

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);
           }
           setState(c);　　　　　// 释放锁的最后，写volatile变量state
           return free;
    }

<table> 
 <thead> 
  <tr> 
   <th align="left">从上面的源代码可以看出，在释放锁的最后<code>写</code>volatile变量state。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">公平锁在释放锁的最后写volatile变量state，在获取锁时首先读这个volatile变量。根据volatile的happens-before规则，释放锁的线程在写volatile变量之前可见的共享变量，在获取锁的线程读取同一个volatile变量后将<code>立即</code>变得对获取锁的线程可见。</td> 
  </tr> 
 </tbody> 
</table>

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

<table> 
 <thead> 
  <tr> 
   <th align="left">该方法以原子操作的方式更新state变量，本文<code>把Java的compareAndSet()方法调用简称为CAS。JDK文档对该方法的说明如下：如果当前状态值等于预期值，则以原子方式将同步状态设置为给定的更新值</code>。此操作具有volatile读和写的内存语义。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">这里我们分别从编译器和处理器的角度来分析，CAS如何同时具有volatile读和volatile写的内存语义。</td> 
  </tr> 
  <tr> 
   <td align="left">前文我们提到过，编译器不会对volatile读与volatile读后面的任意内存操作重排序；编译器不会对volatile写与volatile写前面的任意内存操作重排序。组合这两个条件，意味着为了同时实现volatile读和volatile写的内存语义，编译器不能对CAS与CAS前面和后面的任意内存操作重排序。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">下面我们来分析在常见的intel X86处理器中，CAS是如何同时具有volatile读和volatile写的内存语义的。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">在常见的intel X86处理器中，在sun.misc.Unsafe类的<code>compareAndSwapInt()</code>方法的源代码里的逻辑→程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上 <strong><code>lock 前缀（Lock Cmpxchg）</code></strong>。反之，如果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致性，不需要lock前缀提供的内存屏障效果）。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left"><strong>intel的手册对<code>lock前</code>缀的说明如下</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）确保对内存的读-改-写操作<code>原子执行</code>。</td> 
  </tr> 
  <tr> 
   <td align="left">2）禁止该指令，与之前和之后的<code>读</code>和<code>写</code>指令重排序。</td> 
  </tr> 
  <tr> 
   <td align="left">3）把写缓冲区中的所有数据<code>刷新</code>到内存中。<br></td> 
  </tr> 
  <tr> 
   <td align="left">上面的第2点和第3点所具有的内存屏障效果，足以同时实现volatile读和volatile写的内存语义。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">经过上面的分析，现在我们终于能明白为什么JDK文档说CAS同时具有volatile读和volatile写的内存语义了。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">现在对公平锁和非公平锁的内存语义做个总结。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">·公平锁和非公平锁释放时，最后都要<code>写</code>一个volatile变量state。</td> 
  </tr> 
  <tr> 
   <td align="left">·公平锁获取时，首先会去<code>读</code>volatile变量。</td> 
  </tr> 
  <tr> 
   <td align="left">·非公平锁获取时，首先会用CAS<code>更新</code>volatile变量，这个操作同时具有volatile读和volatile写的内存语义。</td> 
  </tr> 
  <tr> 
   <td align="left">从本文对ReentrantLock的分析可以看出，锁释放-获取的内存语义的<code>实现</code>至少有下面两种<code>方式</code>。</td> 
  </tr> 
  <tr> 
   <td align="left">1）利用volatile变量的写-读所具有的内存语义。</td> 
  </tr> 
  <tr> 
   <td align="left">2）利用CAS所附带的volatile读和volatile写的内存语义。</td> 
  </tr> 
 </tbody> 
</table>

###  concurrent包的实现  ###

Java线程间通信的4种方式

<table> 
 <thead> 
  <tr> 
   <th align="left">由于Java的CAS同时具有volatile读和volatile写的内存语义，因此Java线程之间的通信现在有了下面4种方式。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1）A线程<code>写</code>volatile变量，随后B线程<code>读</code>这个volatile变量。</td> 
  </tr> 
  <tr> 
   <td align="left">2）A线程<code>写</code>volatile变量，随后B线程用<code>CAS更新</code>这个volatile变量。</td> 
  </tr> 
  <tr> 
   <td align="left">3）A线程用<code>CAS更新</code>一个volatile变量，随后B线程用<code>CAS更新</code>这个volatile变量。</td> 
  </tr> 
  <tr> 
   <td align="left">4）A线程用<code>CAS更新</code>一个volatile变量，随后B线程<code>读</code>这个volatile变量。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">Java的<code>CAS</code>会使用现代处理器上提供的 <strong><code>高效机器级别的原子指令</code></strong> ，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键。同时，volatile变量的读/写和CAS可以实现线程之间的通信。把这些特性<code>整合</code>在一起，就形成了整个concurrent包得以实现的基石。</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">如果我们仔细分析concurrent包的源代码实现，会发现一个通用化的<code>实现模式</code>。</td> 
  </tr> 
  <tr> 
   <td align="left">首先，<code>声明</code>共享变量为volatile。</td> 
  </tr> 
  <tr> 
   <td align="left">然后，<code>使用</code>CAS的原子条件更新来实现线程之间的同步。</td> 
  </tr> 
  <tr> 
   <td align="left">同时，配合以volatile的读/写和CAS所具有的volatile读和写的内存语义来实现线程之间的<code>通信</code>。</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left"><code>AQS</code>，<code>非阻塞数据结构</code>和<code>原子变量类</code>（java.util.concurrent.atomic包中的类），这些<code>concurrent包中的基础类</code>都是使用这种模式来实现的，而concurrent包中的高层类又是依赖于这些基础类来实现的。</td> 
  </tr> 
  <tr> 
   <td align="left"><img src="https://img-blog.csdnimg.cn/2659aee00c8442e09f324134dd0bd5b7.png#pic_center" alt="在这里插入图片描述"></td> 
  </tr> 
 </tbody> 
</table>

\-----------------------------------------------------------------------------摘自 书名：Java并发编程的艺术 作者：方腾飞；魏鹏；程晓明