java并发机制的底层实现原理

java代码在编译后会变成java字节码，字节码被类加载器加载到JVM中，JVM执行字节码，最终转换成汇编指令在CPU中执行，java的并发依赖于JVM的实现和CPU的指令。

volatile

volatile是轻量级的synchronized，它保证了多线程中共享变量的可见性（一个线程修改修改一个共享变量，另一个线程能读到这个修改后的值）

CPU 的术语定义

内存屏障：是一组处理器指令，用于实现对内存操作的顺序限制

缓冲行

原子操作

缓冲行填充

缓冲命中

写命中

写缺失

volatile 如何保证可见性

instance = new Singleton() // instance是volatile变量

做了两件事

当前处理器缓存行的数据写回系统内存
这个写回内存的操作会使在其他CPU中缓存了该内存地址的数据无效

对于声明了volatile的变量进行写操作，JVM会发送一条带Lock前缀的指令，将缓存行中的数据写回到内存，同时每个处理器通过嗅探在总线上传播的数据检查自己的缓存是否过期，当发现自己缓存中的内存地址被修改，则将缓存行设置为无效。当处理起对这个数据再进行操作的时候，就回去内存中重新把数据读到处理起缓存中。

两条原则

Lock前缀指令会引起处理起缓存写回到内存
一个处理器的缓存回写到内存会导致其他处理起的缓存无效

volatile的使用优化

追加字节能优化性能？

对于处理器来说，高速缓冲行是64字节，如果队列的头和尾都不足64节点，处理器会将他们读到同一个高速缓冲行，当处理器试图修改头节点时，会将整个缓冲行锁定，导致其他处理器不能访问缓冲行中的尾节点，严重影响效率，追加到64字节的目的就是将头和尾节点放在不同的高速缓冲行中

两种场景下不合适

缓存行非64字节的处理器

共享变量不会频繁的写

在java7中可能不生效，java7会淘汰或重排无用字段

synchronized

synchronized一直被称为重量级锁，但是在1.6之后，引入偏向锁和轻量级锁，她变得不那么重了

synchronized 实现同步的基础：java中的每一个对象都可以作为锁，具体表现：

对于普通同步方法，锁示当前实例对象

对于静态同步对象，锁是当前类的Class对象

对于同步代码块，锁是synchronized括号中配置的对象

java对象头

synchronized的锁是存在java对象头中的。如果对象是数组，则虚拟机用三个字宽存储对象头，对象是非数组，则用2字宽存储在对象头中。一字宽等于4字节，即32bit。

对象头的长度

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

Mark Word 的存储结构

锁状态 25bit 4bit 1bit是否是偏向锁 2bit锁标志位

无锁状态对象中的hashcode 对象分代年龄 0 01

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

Mark Word的状态变化

锁状态	23bit	2bit	4bit	1bit	2bit
				是否是偏向锁	锁标志位
轻量级锁	指向栈中所记录的指针				00
重量级锁	指向互斥量（重量级锁）的指针				10
GC标志	空				11
偏向锁	线程ID	Epoch	对象分代年龄	1	01

锁的状态

锁的状态有四种，从低到高是：

无锁状态
偏向锁状态
轻量级锁状态
重量级锁状态

锁的状态会随着竞争升级，但是不能降级，目的是为了提高获得锁和释放锁的效率

偏向锁

当一个线程访问同步代码块并获取锁时，会在对象头中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步代码块时不需要进行CAS操作加锁和解锁，只需检测mark word中是否存着当前线程的偏向锁。检测成功，表示线程获得了锁。测试失败，则需要检测是否是偏向锁的标志，没有设置，则采用CAS竞争锁，设置了，则使用CAS将对象的偏向锁指向当前线程。

偏向锁的撤销

当其他线程尝试竞争偏向锁时，拥有偏向锁的线程才会释放锁。

关闭偏向锁

默认是有延迟的，关闭延迟：-XX:BiasedLockingStartupDelay=0

如果系统中的锁通常处于竞争状态，则可以关闭偏向锁：-XX:UseBiasedLocking=false，程序默认进入轻量级锁状态。

轻量级锁

加锁：先在当前线程的栈帧中创建用于存储锁记录的空间，再将对象头中的Mark Word复制到锁记录中。然后线程尝试使用CAS将对象头中的Mark Word替换成指向锁记录的指针。如果成功，则当前线程获得锁。如果失败，则表示有其他线程竞争，当前线程采用自旋获得锁
解锁：使用CAS操作将之前复制到锁记录中的再替换回对象头，如果成功，表示无竞争，如果失败，则锁会膨胀为重量级锁。

重量级锁

轻量级锁自旋后会膨胀为重量级锁，当其他线程试图获取锁时，都会被阻塞住，当持有锁的线程释放锁后会唤醒这些线程。

优缺点对比

锁	优点	缺点	场景
偏向锁	加锁解锁几乎无消耗	存在竞争时需要锁撤销的消耗	适用于只有一个线程访问同步代码块
轻量级锁	竞争的线程不会阻塞	存在竞争时自旋消耗CPU	追求相应速度，执行速度非常快
重量级锁	不使用自旋不消耗CPU	线程会阻塞，相应慢	追求吞吐量

原子操作的实现原理

原子操作指的是不可被中断的一系列操作。

术语	英文	解释
缓冲行	Cache line	缓存的最小操作单位
比较并交换	compare and swap(CAS)	CAS 操作需要输入两个数值，一个旧值（期望操作前的值）和新值，在操作期间先比较旧值有没有变化，没有变化才交换成新值，发生变化则不交换
CPU流水线	CPU pipeline
内存顺序冲突	Memory order violation

处理器如何实现原子操作

处理器基于总线锁定和缓存锁定来实现内存操作的原子性

Java如何实现原子操作

java中可以通过锁和循环CAS的方式来实现原子操作，自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止。

    private AtomicInteger atomicI = new AtomicInteger(0);
    /**
     * 使用cas实现线程安全的计数器
     */
    private void safeCount() {
        for (; ; ) {
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    .
    .
    .
        // cas的操作
    private static final Unsafe unsafe = Unsafe.getUnsafe();

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

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

ABA问题。A变成B，再变成A，CAS检查的时候会发现它没有变化，实际变化。解决方案是加上版本号，即1A->2B->3A，java1.5开始AtomicStampedReference 专门来解决这个问题。
循环时间长开销大。
只能保证一个共享变量的原子操作。可以将多个共享变量合并成一个共享变量，比如i=2,j=a,ij=2a，然后用CAS操作ij，java1.5开始，jdk提供了atomicReference来保证对象之间的原子性。或者就是使用锁机制。

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

jvm 除了偏向锁，其他实现锁的方式都用了循环CAS。