Java并发机制的底层实现_java并发底层代码-优快云博客

Java并发机制的底层实现

Java代码在编译成字节码后，需要类加载器加载到JVM中，JVM执行字节码，将字节码转化为汇编指令在CPU上执行，Java中所使用的并发机制依赖于JVM的实现和CPU指令

volatile的应用

在并发编程中synchronized和volatile有着重要作用，volatile是轻量级的synchronized，在多线程编程中它控制共享变量的可见性。即被volatile修饰的共享变量，在一个线程中修改后，在另一个线程中能立即读到修改后的值。恰当的使用volatile变量修饰符，比synchronized执行成本更低。因为它不会引起线程上下文切换和调度

volatile的定义与实现

volatile定义如下:
Java编程语言允许线程访问共享变量，为确保共享变量能被准确和一致更新，线程应该确保通过排他锁单独获得这个变量

volatile某些情况下比锁更方便，如果一个共享变量被声明为volatile，Java线程内存模型确保所有线程看到的这个变量值是一致的

由于实现依赖于具体处理器，因此我们先看一下与实现相关的CPU术语

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

有volatile变量修饰的共享变量进行写操作时，会多出Lock指定代码，通过查找IA-32架构软件开发者手册可知，Lock前缀的指令在多核处理器下会发生两件事情

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

为提高处理速度，处理器不直接和内存进行通信，而是将系统内存的数据读取到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。如果对声明volatile的变量进行写操作，JVM会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存，但如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题，所以在多处理器下，为保证各个处理器的缓存是一致的，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期，当处理器发现自己缓存行对应的内存地址被修改，会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作时，会重新从系统内存中把数据读取到处理器缓存中

synchronized的实现原理与应用

在多线程编程中synchronized被广泛应用，人们都习惯称它为重量级锁。但在Java SE 1.6对其进行优化过后在一些情况下并没有想象中的那么糟糕，为减少在获得锁及释放锁上的性能消耗，引入了偏向锁和轻量级锁，以及锁的存储结构和升级过程

在通过synchronized实现同步时，Java中的每个对象都可以作为锁，在默认情况下有以下三种形式

同步普通方法，锁是当前实例对象
同步静态方法，锁是当前类的Class对象
同步方法块，锁是Synchronized括号中的配置对象

JVM中通过进入和退出Monitor对象来实现方法同步和代码块同步，但实现细节不同。代码块同步是使用monitorenter和monitorexit指令实现，方法同步则使用另一种实现方式。monitorenter指令在编译后插入到同步代码块的开始位置，monitorexit是插入到方法结束处和异常处，JVM需要保证每个monitorenter必须要有对应的monitorexit匹配。任何对象都关联有一个monitor，当monitor被持有后，对象将处于锁定状态。线程执行到monitorenter指令时，将尝试获取对象对应的monitor，当获取到对应的monitor之后即已经获取到锁

Java对象头

synchronized用的锁是存在Java对象头中，对于数组类型，使用3个字宽存储对象头，对非数组类型，则用2个字宽存储对象头。在32位虚拟机中，1字宽等于4字节，即32bit

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

Java对象头中的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位。在32位JVM中Mark Word存储结构如下

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

Mark Word中存储的数据会随着锁标志位的变化而变化，一共有一下4种变化

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

64位虚拟机下，Mark Word是64bit大小

锁状态	25bit	31bit	1bit	4bit	1bit	2bit
锁状态	25bit	31bit	cms_free	分代年龄	偏向锁	锁标志位
无锁	unused	hashCode			0	01
偏向锁	ThreadID(54bit) Epoch(2bit)				1	01

锁的升级和对比

Java SE 1.6为减少获得锁和释放锁带来的性能消耗，引入了"偏向锁"和"轻量级锁"。在Java SE 1.6中，锁一共有4种状态，级别从低到高分别为：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态随着竞争情况逐渐升级。锁可以升级但不能降级，这种设计是为了增加获得锁和释放锁的效率

偏向锁

大多数情况下，锁总是由同一线程多次获取，并不存在多线程竞争，因此为了降低线程获取锁的代价引入了偏向锁。当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录中存储锁偏向的线程ID，以后该线程在进入和退出同步块时不需要进行CAS操作来加锁和解锁，只需要简单测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置为1，如果为1表示当前为偏向锁，则尝试使用CAS将对象头的偏向锁指向当前线程；如果没有设置，则使用CAS竞争锁

撤销偏向锁

偏向锁使用一种等到竞争出现才释放锁的机制，当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。撤销偏向锁需要等到全局安全点才会进行，在全局安全点上没有正在执行的字节码。撤销偏向锁首先会暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果不处于活动状态，则将对象头设置为无锁状态；如果线程仍然活着，拥有偏向锁的栈会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他线程，要么恢复到无锁或标记对象不适合作为偏向锁，最后唤醒暂停的线程

关闭偏向锁

偏向锁默认是启用的，但在应用程序启动几秒之后才激活，也可以通过JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。如果确定大部分情况下都处于竞争状态，可以通过-XX:-UseBiasedLocking=false来关闭偏向锁，程序默认进入轻量级锁状态

轻量级锁

轻量级锁加锁

线程在执行同步块之前，JVM会先在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中。之后线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功当前线程获得锁，如果失败，则有其他线程竞争锁，当前线程尝试使用自旋获取锁

轻量级锁解锁

轻量级锁解锁时，会通过原子的CAS操作将锁记录中的Mark Word替换回对象头，成功，则表示没有竞争。失败，表示当前锁存在竞争，锁会膨胀成重量级锁

自旋会消耗CPU，为避免无用的自旋，一旦锁升级为重量级锁，将不能在恢复到轻量级锁状态。当锁升级为重量级锁，其他线程试图获取锁会被阻塞住，当持有锁的线程释放锁之后会唤醒所有竞争锁的线程，被唤醒的线程会进入新一轮的获取锁竞争

锁的优缺点对比

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

原子操作实现原理

原子操作指不可被中断的一个或一系列操作，在多处理器上实现原子操作比较复杂，我们看一下在Intel处理器和Java里如何实现原子操作

术语名称	英文	解释
缓存行	Cache line	缓存最小操作单位
比较并交换	Compare and Swap	CAS操作需要输入两个数值，一个旧值，即期望操作前的值；一个新值。在操作期间先比较旧值有没有发生变化，如果没有变化，则替换为新值，发生变化则不替换
CPU流水线	CPU pipeline	CPU中由5～6个不同功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5～6步后再由这些电路单元分别执行，这样能在一个CPU时钟期间完成一条指令，因此提高CPU的运算速度
内存顺序冲突	Memory order violation	内存顺序冲突一般是由假共享引起，假共享是指多个CPU同时修改同一个缓存行的不同部分引起其中一个CPU的操作无效，当出现内存顺序冲突时，CPU必须清空流水线

处理器原子操作的实现逻辑

32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作。处理器会保证基本的内存操作的原子性，处理器保证从系统内存中读取或者写入一个字节是原子的，也就是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。处理器能自动保证单处理器对同一缓存行里进行16/32/64位的操作是原子的，但复杂内存操作处理器是不能自动保证原子性，如跨总线宽度、跨多个缓存行和跨页表访问。处理器提供了总线锁定和缓存锁定机制来保证复杂内存操作的原子性

总线锁定保证原子性

总线锁保证原子性。多个处理器同时对共享变量进行读改写操作，例如时常用到的i++操作，那么共享变量就会被多个处理器同时处理，读改写操作就会有并发操作问题，操作完成之后共享变量的值会和期望的不一致

上述问题产生的原因是多个处理器同时从各自的缓存中读取变量i，分别进行加1操作，分别写入系统内存。要保证读改写共享变量操作的原子性，需要保证CPU1在读改写共享变量时，CPU2不能操作缓存了该共享变量内存地址的缓存

通过总线锁可以保证读改写共享变量的原子性，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，该处理器将独占内存

缓存锁保证原子性

由于总线锁定的代价太大，因此有些场景下使用缓存锁定来代替减少开销。缓存锁定保证同一时刻，对某个内存地址的操作是原子的。

目前的处理器中对于频繁使用的内存会缓存在处理器的L1、L2和L3高速缓存中，原子操作可以直接在处理器内部缓存中进行，不需要声明总线锁。缓存锁定就是如果内存区域被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，当执行锁操作回写到内存时，处理器不在总线上声言LOCK #信号，而是修改内部的内存地址，并允许缓存一致性机制来保证操作的原子性，缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。例如当CPU1修改缓存行中的i时使用了缓存锁定，CPU2不能同时缓存i的缓存行

但是有两种情况处理器不会使用缓存锁定

情况一：当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时，处理器会调用总线锁定
情况二：有些处理器不支持缓存锁定

Java中原子操作实现

Java中可以通过锁和循环CAS的方式实现原子操作

循环CAS实现原子操作

JVM中的CAS操作则是利用处理器提供的CMPXCHG指令实现。自旋CAS实现的基本思路是循环进行CAS操作直到成功为止，以下代码通过CAS操作实现一个线程安全的计数器方法safeCount和一个非线程安全的计数器count

package org.aim.cas;

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

public class Counter {
    private AtomicInteger atomicI = new AtomicInteger(0);
    private int i = 0;
    public static void main(String[] args){
        final Counter cas = new Counter();
        List<Thread> ts = new ArrayList<Thread>(600);
        long startTime = System.currentTimeMillis();
        for(int j = 0; j < 100; j++){
            Thread t  = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i< 10000; i++){
                        cas.safeCount();
                        cas.count();
                    }
                }
            });
            ts.add(t);
        }
        for (Thread t : ts){
            t.start();
        }
        // 等待所有线程执行完成
        for (Thread t : ts){
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicI.get());
        System.out.println(System.currentTimeMillis() - startTime);
    }

    // 线程安全
    private void safeCount(){
        for(;;){
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);
            if (suc){
                break;
            }
        }
    }

    // 非线程安全
    private void count(){
        i++;
    }
}

自Java 1.5开始，在并发包中提供了一些类来支持原子操作，如AtomicBoolean、AtomicInteger、AtomicLong等

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

在Java并发包中有些并发框架也使用了自旋CAS的方式来实现原子操作，如LinkedTransferQueue类的xfer方法。CAS虽然可以高效的解决原子操作，但仍然有三大问题

ABA问题：CAS的逻辑是如果操作值没有发生变化，则使用新值更新。但如果一个值从A，变成B，再变成A。CAS在操作时判断值没有发生变化，但其实已经发生变化。对于这种情况有一种解决方法是，带上版本号，在变量前添加版本号，每次变量更新时把版本号加一，这样A -> B -> A就变成了1A -> 2B -> 3A。JDK 中java.util.concurrent.atomic包中AtomicStampedReference类中的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指令一方法可以延迟流水线执行指令，使CPU不会消耗过多的资源，延迟时间取决于具体实现版本；另一方面可以避免因为退出循环时因为内存顺序冲突而引起CPU流水线被清空
只能保证一个共享变量的原子操作：当对一个共享变量执行操作时，可以使用循环CAS的方式来保证原子操作，但对于多个共享变量操作时，我们可以使用锁。还有一种方式是把多个共享变量合成一个来操作。例如有两个共享变量i=2,j=a，合并成ij=2a，之后再使用CAS来操作变量ij。JDK也提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象中进行CAS操作，并提供了compareAndSet方式实现更新操作