写在前面

1、volatile 的应用

1.1 连接CPU的相关术语与说明

术语	英文单词	术语描述
内存屏障	memory barriers	是一组处理器指令，用于实现对内存操作的顺序限制
缓冲行	cache line	CPU高速缓存中可以分配的最小单位。处理器填写缓存行时会加载整个缓存行，现代CPU 需要执行几百次CPU指令
原子操作	atomic operations	不可中断的一个或者一系列操作
缓存行填充	cache line hit	当处理器识别到从内存中读取操作数是缓存的，处理器读取整个缓存行到适当的缓存（L1 \L2 \L3）
缓存命中	cache hit	如果进行高速缓存行填充操作的内存位置仍然是下次处理器访问的地址时，处理器从缓存中读取操作数，而不是内存
写命中	write hit	当处理器将操作数协会到一个内存缓存的区域时，他会首先检查这个缓存的内存地址是否在缓存行中，如果存在一个有效的缓存行，则处理器会将这个操作数写回到缓存，而不是写回到内存，这个操作就是写命中
写缺失	write misses the cache	一个有效的缓存行被写入到不存在的内存区域

1.2 volatile是如何保证内存可见性的

// java 代码
// instance 被 volatile关键字修饰
instance = new Singleton();

// 通过工具获取的JIT编译器生成汇编指令如下
0x01a3deld: movb $0.....: lock add1 $x0,(%esp);

• 将处理器缓存行的数据写回到系统内存

• 这个写回内存的操作会使在其他CPU缓存了该内存地址的数据无效

2、synchronized的实现原理与应用

• 对于普通同步方法，锁的是当前实例对象

• 对于静态同步方法，锁的是类的class对象

• 对于同步方法块，锁的是synchronized括号里配置的对象

• monitorenter指令是在编译后插入到同步代码块的开始位置

• monitorexit指令插入到方法结束的位置和异常处

• JVM要保证每个monitorenter必须有与之对应的monitorexit配对

• 任何对象都有一个monitor与之关联

• 当一个monitor被持有后，它将处于锁定状态

• 线程执行monitorenter指令时，将会尝试获取对象对应的monitor的所有权，即尝试获得对象的锁

2.1 Java对象头

Java对象头的长度

长度	内容	说明
32/64bit	Mark Word	存储对象的hashCod或锁信息
32/64bit	Class Metadata Address	存储到对象类型数据的指针
32/64bit	Array length	数组的长度（如果当前对象是数组）

Java对象头存储结构

锁状态	25bit	4bit	1bit是否是偏向锁	2bit锁标志位
无锁状态	对象的hashCode	对象的分代年龄	0	01

2.2 锁升级与对比

2.1.1 偏向锁

2.1.1.1 偏向锁的获取

2.1.1.2 偏向锁的撤销（非常妙这里）

2.1.1.3 关闭偏向锁

# 关闭偏向锁延迟
-XX:BiasedLockingStartupDelay=0

# 关闭偏向锁 程序默认进入轻量级锁状态
-XX:-UseBiasedLocking=false

2.1.2 轻量级锁

2.1.2.1 轻量级锁加锁

2.1.2.2 轻量级锁解锁

2.1.3 锁的优缺点对比

锁的优缺点对比

锁	优点	缺点	适用场景
偏向锁	加锁和解锁过程不需要额外的消耗，和执行非同步方法相比仅存在纳秒级别的差异	如果线程存在锁竞争，会带来额外的锁撤销开销	适用于只有一个线程访问同步代码块
轻量级锁	竞争的线程不会阻塞，提高了程序的响应速度	如果始终得不到锁竞争的线程，使用自旋会消耗CPU	追求响应时间，同步代码块执行速度非常快
重量级锁	线程竞争不适用自旋，不会消耗CPU	线程阻塞，响应时间慢	追求吞吐量，同步块执行速度较长

3、Java中如何实现原子操作

3.1 使用循环CAS实现原子操作

package com.liziba;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @auther LiZiBa
 * @date 2021/2/28 17:39
 * @description: 计数器实现
 **/
public class Counter {

    // 安全计数器统计数
    private AtomicInteger atomicInteger = new AtomicInteger(0);
    // 非安全计数器统计数
    private int i = 0;

    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> threads = 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();
                }
            });
            threads.add(t);
        }
        // 启动线程
        threads.forEach(t -> t.start());
        // join等待所有线程执行完毕
        for (Thread t : threads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 输出不安全计数器结果、安全计数器结果、程序执行时间
        System.out.println(cas.i);
        System.out.println(cas.atomicInteger.get());
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 安全计数器
     */
    private void safeCount() {
        i++;
    }

    /**
     * 非安全计数器
     */
    private void count() {
        for (;;) {
            int i = atomicInteger.get();
            // CAS 增加
            // 注意使用 ++i
            boolean set = atomicInteger.compareAndSet(i, ++i);
            // 设置成功退出死循环
            if (set) {
                break;
            }
        }
    }
}

# 运行结果
711319
1000000
265

Process finished with exit code 0

3.1.1 CAS 实现原子操作的三大问题

• ABA问题：因为CAS需要在操作值的时候，检查值是否发生了变化，如果没有变化则更新，但是如果一个值从A修改为B又修改为A，那么使用CAS就无法发现值发生了变化，但实际上发生了变化。解决方案如下

• 使用版本号解决，将原本的A-->B-->A问题变成1A-->2B-->3A则可以解决

• 使用JDK Atomic包里提供的AtomicStampedReference来解决ABA问题，这个类compareAndSet方法会首先比较当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等则以原子方式替换，源码如下。

  public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

• 循环时间长开销大：自旋CAS如果长时间不成功，会给CPU带来非常大的开销。解决这个问题需要JVM能支持处理器提供的pause指令，效率会有一定的提升。pause指令的两个作用如下

• 延迟流水线执行指令（de-pipeline），使CPU不会消耗过多执行资源

• 避免在退出循环时内存顺序冲突（Memory Order Violation）而引起CPU流水线被清空

• 只能保证一个共享变量的原子操作：对多个共享变量进行操作的时候CAS无法保证原子性，解决方案如下

• 使用锁

• 变量合并

• 使用JDK提供的AtomicReference类来保证引用对象之间的原子性，将多个变量放置于对象中

3.2 使用锁机制实现原子操作

• 《Java并发编程的艺术》-- 方腾飞 魏鹏 程晓明 著

• 百度百科

• CSDN部分博客