并发编程—《Java并发编程的艺术》学习笔记第二章 Java并发机制的底层实现原理

本是古典何须时尚 2021-10-01 08:44 319阅读 0赞

###### Java并发编程的艺术 ######

###### 所有笔记：[https://www.jianshu.com/nb/33534473][https_www.jianshu.com_nb_33534473] ######

###### Github地址：[https://github.com/ilssio/java-concurrency-programming-ilss][https_github.com_ilssio_java-concurrency-programming-ilss] ######

Java代码->Java字节码->JVM执行字节码->汇编指令

Java中并发机制依赖于JVM实现和CPU指令集。

## 2.1 volatile的应用 ##

*  volatile 在多处理器开发中保证共享变量的“可见性”，当多个线程同时访问共享变量的时候，volatile修饰的变量的被某个线程改变可以被其他线程感知。

1.  volatile的定义于实现原理
    
    如果一个字段被声明成volatile，Java线程内存模型确保所有线程看到这个变量的值是一致的。
    
     *  CPU术语
    
    <table> 
     <thead> 
      <tr> 
       <th style="text-align:center">术语</th> 
       <th style="text-align:left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td style="text-align:center">内存屏障（memory barriers）</td> 
       <td style="text-align:left">是一组处理器指令，用于实现对内存操作的顺序限制</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">缓冲行（cache line）</td> 
       <td style="text-align:left">缓存中可以分配的最小存储单位。处理器填写缓存线时会加载整个缓存线，需要使用多个主内存读周期</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">原子操作（atomic operations）</td> 
       <td style="text-align:left">不可中断的一个或一系列的操作；</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">缓存行填充（cache line fill）</td> 
       <td style="text-align:left">当处理器识别到从内存中读取操作数是可缓存的，处理器读取整个缓存行到适当的缓存；</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">缓存命中（cache hit）</td> 
       <td style="text-align:left">如果进行高速缓存行填充操作的内存位置任然是下次处理器访问的地址时，处理器从缓存中读取操作数，而不是从内存中读取；</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">写命中（write hit）</td> 
       <td style="text-align:left">当处理器操作数写回到一个内存缓存的区域时，它首先会检查这个缓存的内存地址是否在缓存行中，如果存在一个有效的缓存行，则处理器将这个操作数写回到缓存，而不是写回到内存，这个操作被称为写命中；</td> 
      </tr> 
      <tr> 
       <td style="text-align:center">写缺失（write miss the cache）</td> 
       <td style="text-align:left">一个有效的缓存行被写入到不存在的内存区域。</td> 
      </tr> 
     </tbody> 
    </table>
    
        volatile SomeVar instanse = new Singleton();
    
    转换成X86汇编代码
    
        movb $0*), 0*1104800;
        lock addl $0*0,(%esp);
    
    有volatile修饰的共享变量进行写操作会有第二行lock指令。
    
     *  lock指令：
        
        1）将当前处理器缓存行数据写回到内存
        
        2）这个写会让在其他CPU里缓存了该地址的数据无效
    
    在多处理器下，为了保证各个处理器的缓存是一致的，会实现缓存一致性协议。每个处理器通过探知总线上传输的数据来检测自己的缓存是否过期，如果发现自己的缓存行对应的内存地址被修改，则会将当前处理器的缓存设为无效，当要对这个数据进行修改操作的时候，会重新再系统内存中读入CPU缓存。
    
     *  volatile实现的两条原则：
        
        1）Lock前缀指令会引起处理器缓存回写到内存。
        
        2）一个处理器的缓存回写到内存会导致其他处理器的缓存无效。
    
    1.  volatile的使用优化：
        
         *  讲共享变量追到处理器位数，32位->32字节，32/4=8；64位->64字节，64/8=16
         *  书上给了一个LinkedTransferQueue的类，Java8已经不是书上的样子了。
         *  Java7过后变得更加智慧了。淘汰或者重新排列了无用字段。

## 2.2 synchronized 的实现原理与应用 ##

Java中每个对象都可以作为锁，有以下三种形式：

*  对于普通同步方法，锁的是当前实例对象。
 *  对于静态同步方法，锁的是当前类的Class对象（Object.class）
 *  对于同步代码块，锁的是括号内的对象。可以是普通的object，也可以是object.class

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步

代码块同步是使用monitorenter和monitorexit指令实现的，同步方法是另外的一种方式实现的。

monitorenter和monitorexit指令在编译后插入到同步代码块的开始、结束处或异常处，JVM要保证每个enter都有exit与之匹配。

任何对象都有一个monitor与之关联，当且一个monitor被持有之后，就处于锁定状态，线程执行到enter指令的时候，会尝试获取对象所对应的monitor的所有权，即获取对象的锁。

### 2.2.1 Java对象头 ###

synchronized用的锁是存在Java对象头里面的。

对象是数组：3个字宽存储对象头

对象非数组：2个字宽存储对象头

注：32位1字宽等于4字节，即32bit

### 2.2.2 锁的升级与对比 ###

Java SE 6 中锁一共有4种状态，级别从低到高：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。这几个状态会随着竞争情况逐渐升级。

锁可以升级但是不能降级。

1.  偏向锁：
    
    线程访问同步快并获得锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程id
    
    进入和退出同步块：
    
     1）检测对象头的Mark Word是否存了当前线程的偏向锁。存了表示已经获得锁
    
     2）没有继续测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）设置了就尝试使用CAS将对象头的偏向锁指向当前线程
    
     3）如果没有设置，就使用CAS竞争锁
    
    偏向锁的撤销：
    
     当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。
    
     锁的撤销需要等待全局安全点（在这个时间上没有正在执行的字节码）
    
     先暂停拥有偏向锁的线程，然后检查该线程是否活着，不处于活动状态，则将对象头设置成无锁状态，如果活着，拥有偏向锁的栈就会被执行，遍历对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向其他线程，要么回复到无锁或者标记对象不合适偏向锁，最后唤醒暂停的线程。
    
    关闭偏向锁：
    
     Java6 以后偏向锁是默认启用的。但是要在程序启动几秒后才激活。
    
     可以通过JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0
    
     可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false 程序会默认进入轻量级锁状态。
2.  轻量级锁：
    
    轻量级锁加锁：
    
     线程执行同步块之前，JVM或在想成的栈帧中创建用于存储锁记录的空间，将对象头中的Mark Word复制到锁记录中。然后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。成功当前线程获得锁，失败则表示其他线程竞争锁，当前线程则会尝试使用自旋来获取锁
    
    轻量级锁解锁：
    
     解锁时，使用原子的CAS操作将Displaced Mark Word替换回到头，如果成功，则没有发生竞争，如果失败，表示当前锁存在竞争，锁就会变成重量级锁。

## 2.3 原子操作的实现原理 ##

2.处理器如何实现原子操作：

处理器实现原子操作：现在的处理器都能懂保证单处理对同一个缓存行里进行的16/32/64位的操作是原子的。

对于复杂的内存操作，处理器不保证，但是提供了两个机制来保证复杂内存操作的原子性：总线锁定和缓存锁定。

1）总线锁定就是使用了处理器提供的LOCK\#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞，此时该处理器就可以独占内存。

2）缓存锁定是指内存区域如果被缓存在处理器缓存中，在Lock操作期间被锁定，那么它之心锁操作回写到内存时会修改内部的内存地址，并允许他的缓存一致性机制来保证操作的原子性。 缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

处理器两种不会使用缓存锁定的情况：

*  操作的数据不能被缓存在处理器内部，或者操作的数据跨多个缓存行，则会调用总线锁定
 *  有些处理器不支持缓存锁定。

1.  Java中如何实现原子操作：
    
    Java实现原子操作的两种方式 **锁** 和 **循环CAS**
    
    1）使用循环CAS实现原子操作：
    
        package io.ilss.concurrency.part02;
        
        import java.util.ArrayList;
        import java.util.List;
        import java.util.concurrent.atomic.AtomicInteger;
        
        /**
         * className Counter
         * description Counter
         *
         * @author feng
         * @version 1.0
         * @date 2019-01-21 22:21
         */
        public class Counter {
            private AtomicInteger atomicInt = new AtomicInteger(0);
            private int i = 0;
        
            public static void main(String[] args) throws InterruptedException {
                final Counter cas = new Counter();
                List<Thread> ts = new ArrayList<>(600);
                long start = System.currentTimeMillis();
                for (int j = 0 ; j< 100; j++) {
                    Thread t = new Thread(() -> {
                        for (int i = 0; i < 10000; i++) {
                            cas.count();
                            cas.safeCount();
                        }
                    });
                    ts.add(t);
                }
                for (Thread t : ts) {
                    t.start();
                }
                for (Thread t : ts) {
                    t.join();
                }
                System.out.println(cas.i);
                System.out.println(cas.atomicInt);
                System.out.println(System.currentTimeMillis() - start);
            }
            private void safeCount() {
                while (true) {
                    int i = atomicInt.get();
                    boolean suc = atomicInt.compareAndSet(i, ++i);
                    if (suc) {
                        break;
                    }
                }
            }
        
            private void count() {
                i++;
            }
        }
    
        995994
        1000000
        193
        
        Process finished with exit code 0
    
    CAS实现原子操作的三大问题：
    
    1.  ABA问题，简而言之则是检查时没发生变化，但是实际上变化了。ABA解决的思路就是使用版本号：1A->2B->3C...，Java1.5之后官方提供了一个AtomicStampedReference来结局ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并检查当前标志是否等于预期标志，如果全部相等，则执行原子操作进行更新。
    2.  循环时间开销大，
    3.  只能保证一个共享变量的原子操作，循环CAS的方式只适用于一个共享变量，如果多个共享变量则需要用锁，不过java1.5之后提供了一个AtomicReference类来保证引用对象之间的原子性，可以吧多个变量放在一个对象里来进行操作CAS操作。
    4.  使用锁机制来实现原子操作， 锁机制保证了只有获得锁的线程才能操作锁定的内存区域。JVM中偏向锁、轻量级锁和互斥锁都实现了。另外除了偏向锁，其他所都实现了CAS。

[https_www.jianshu.com_nb_33534473]: https://www.jianshu.com/nb/33534473
[https_github.com_ilssio_java-concurrency-programming-ilss]: https://github.com/ilssio/java-concurrency-programming-ilss