锁

面试题

一、CAS

AtomicInteger的incrementAndGet(), 使用的是CAS-unsafe的方法-lock cmpxchg

二、对象在内存的存储布局

Object o = new Object(); 

答案：24个字节。markword（8个字节）、class pointer（4个字节，用了UseCompressedClassPointers）、padding（4个字节，为了保证是8字节的倍数）
其它：

• 我们可以使用JOL(Java Object Layout)来显示打印对象的信息

• 确定是否为UseCompressedClassPointers可以通过java -XX:+PrintCommandLineFlags -version来查看

• markword包括 image.png
  • GC信息【分代年龄：4个bit表示，普通的15，CMS是6】
  • hashCode（调用后才会有），锁升级后会放到线程栈种的Lock Record里
  • 锁升级
    • 无锁态
    • 偏向锁（适合一个线程很短时间使用后释放，且反复使用）：包含JavaThread当前线程指针
    • 自旋锁（有线程竞争）：包含线程栈中Lock Record的指针。好处：用户态，所以效率高；坏处：占用CPU资源
    • 重量级锁（竞争激烈，自旋超过10次或者等待线程超过CPU核数一半、或者自适应自旋，向OS申请资源）：指向互斥量（重量级锁）的指针。好处：锁有队列，当线程没有拥有锁时不消耗CPU资源在wait（也就是自旋线程会阻塞，进入阻塞队列进行等待）

• 锁消除 lock eliminate
  StringBuffer是线程安全的，但当jdk发现该对象是在方法内部且不为其它线程使用，则jvm会自动消除StringBuffer对象内部的锁

public void add(String str1,  String str2) {
  StringBuffer sb =  new StringBuffer();
  sb.append(str1).append(str2);
}

• 锁粗化 lock coarsening
  jvm检测到while一直会对同一个对象加锁解锁，此时jvm会将加锁的范围粗化到这一连串操作(while循环外)，使得一连串操作只需要加一次锁即可

public String test(String str) {
  int i = 0;
  StringBuffer sb =  new StringBuffer();
  while(i < 1000) {
    sb.append(str);
    i++;
  }
  return sb.toString();
}

三、synchronized实现过程

实际的各个层级

1. java代码：synchronized
2. 字节码实现：monitorenter、moniterexit。通过IDEA-View-Show Bytecode with jclasslib
3. 执行过程过程中自动升级（无锁-偏向锁-自旋锁-重量级锁）
4. lock cmpxchg：通过自旋改变一个值

四、volatile

1. 线程可见性
2. 禁止指令重排序（禁止乱序）
3. lock addl 0x0(esp)（只是个屏障）：在某个寄存器上+0，所有之前的关于内存指令都需要执行结束后刷到内存里，后面的才能继续执行

超线程

• 原先CPU的核里面有ALU(计算)、PC（记录线程指令位置）、Register（记录数据）的组合，如果要进行线程切换context switch，需要把PC和Register的信息都存储后再导入另一个线程的信息来执行
• 现在一个核里边一个ALU，但是有多个PC/Register的组合，这样线程切换的时候就不需要将数据进行导出导入，直接切换ALU指向即可，提高了切换效率。所谓的四核八线程也即这个原因

cache line缓存行

cacheLine.png

• CPU数据的来源从近及远依次是L1 Cache, L2 Cache, L3 Cache（多个核或者多个CPU公用）以及main memory，也就是先从近的读取，如果没有再逐渐向外读取。
• 由于程序局部性原理，会把数据按块读取。
• 数据块，就是cache line，64字节
• CPU层级的数据一致性volatile，是以cache line为单位的
• 缓存行对齐：对于有些特别敏感的数字，会存在线程高竞争的访问，为了保证不发生伪共享（两个数字在同一个缓存行，但长期被两个不同的线程使用），可以使用缓存行对齐的编程方式；可以补齐到64字节，避免volatile可见性带来的效率低下问题。disruptor（环形队列）
  • JDK8 ： @Contended，保证变量和别的变量不在同一个缓存行；需要加JVM参数-XX:-RestrictContended
• MESI Cache缓存一致性协议[缓存锁]：x86 intel CPU的协议，表示modified、exclusive（独占整个缓存行）、shared、invalid（一个cpu修改了另一个的就是失效的）
  • 但是，有可能存在一个缓存行放不下的情况，这个时候，就要用到锁总线：CPU要访问内存时，将所有CPU到内存的总线锁住，只允许自己访问，以保证缓存一致性，效率低

禁止指令重排序，保证有序性

1. 代码层面 volatile i
2. 字节码层面 ACC_VOLATILE 加标志
3. JVM层面是通过内存屏障来实现（loadloadBarrier, storestoreBarrier, lsBarrier， slBarrier）（sfence mfence lfence等系统原语）
   • 写操作前后ss和sl，读操作前后ll和ls
4. 系统层面最终是通过lock指令，锁总线

美团面试题二

DCL(double check lock）与volatile的问题？

• 为什么要DCL？如果没有内层判断null，此时如果在A线程判断外部INSTANCE == null通过和进入synchronized之前，有B线程也判断并且创建获取新对象退出，此时A线程再进入synchronized又会获得另一个对象，导致了多线程问题
• 为什么要volatile。对象在创建过程中，有以下三个主要步骤。这三个指令如果出现了乱序，A线程再获取对象时先astore将栈指向了内存对象（半初始化状态，成员变量还是默认值），B线程来尝试获取会直接返回INSTANCE得到了一个半初始化的对象
  • 内存中new对象（此时成员变量是默认值）
  • invokespecial（构造函数并给成员变量赋值）
  • astore（将栈上对象执行内存new出的对象）

public class Mgr06() {
  private static volatile Mgr06 INSTANCE;
  private Mgr06(){}
  ConcurrentHashMap chm = null;
  public static Mgr06 getInstance() {
    if(INSTANCE == null) {
      synchronized(Mgr06.class) {
        if(INSTANCE == null) {
          try {
            Thread.sleep(1);
          } catch(InterruptedException e) {
            e.printStackTrace();
          }
          INSTANCE = new Mgr06();
        }
      }
    }
    return INSTANCE;
  }
}

系统底层保证数据一致性/可见性

• （JVM层面内存屏障）
• CPU层面
  • 能用MESI就使用MESI

  • 如果数据大，超过了缓存行，则用锁总线（某个线程访问一个内存时，其它的线程会被锁了不允许访问）
    【书签：p7 1:56】

    
    image.png

参考

• 马士兵Java多线程高并发编程
• 马士兵菜鸟预习