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

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

 

volatile的应用

         在多线程并发编程中synchronized和volatile都扮演着重要的角色，volatile是轻量级synchronized，它在多处理开发中保证了共享变量的“可见性”。可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。如果volatile变量修饰符的使用恰当的话，它比synchronized的使用和执行成本更低，因为它不会引起线程上下文的切换和调度。

         Java语言规范第三版中对volatile的定义：Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排它锁单独获得这个变量。

 CPU术语定义

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

 

 

 

volatile是如何来保证可见性的呢？通过工具获取JIT编译器生成的汇编指令来查看对volatile进行写操作时，CPU会做什么事情。

instance = new Singleton(); //instance 是volatile变量
汇编代码
0x01a3de1d: movb $0x0,0x1104800(%esi);0x01a3de24;lock add1 $0x0,(%esp);

       由volatile变量修饰的共享变量进行写操作时候会多出第二行汇编代码，Lock前缀的指令在多核处理器下会引发两件事情。

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

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

 

synchronized实现原理与应用

      在多线程并发编程中synchronized一直是元老级的角色，通常称为重量级锁。随着Java SE1.6对synchronized进行了各种优化后，有些情况下它并没有那么重。

      Java中的每一个对象都可以作为锁，具体表现为以下三种形式。

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

      当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。那么锁到底存在哪里呢？锁里面会存储什么信息呢？

      从JVM规范中可以看到synchronized在JVM的实现原理，JVM基于进入和退出Monitor对象来实现方法同步和代码同步，但两者的实现细节不一样。代码块同步是使用monitorenter和monitorexit指令实现的，而方法同步是使用的另外一种方式实现的，JVM规范中没有对细节做说明。

       monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。

 

Java对象头

         synchronized用的锁是存在对象头里的。如果对象是数组类型，则虚拟机用3个字宽(word)存储对象头，如果对象是非数组类型，则用3字宽存储对象够。在32位虚拟机中1字宽等于4字节，即32bit.

 Java对象头的长度

长度	内容	说明
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里面存储的数据会随着锁标志位的变化而变化。Mark Word可能变化为存储以下4中数据。

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

 

 

锁的升级与对比

       Java SE1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在Java SE1.6中，锁一共有4中状态，级别从低到高依次是:无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。

 

偏向锁

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

 

偏向锁的撤销

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

 

 

关闭偏向锁

      偏向锁在Java 6和Java 7里默认启用的，但是在应用程序启动几秒钟之后才激活，如果有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartDelay=0,如果确定应用程序里面所有的锁通常情况下处于竞争状态，可以通过JVM参数关闭偏向锁：-XX:-UseBiasedLocking=false,那么程序默认会进入轻量级锁。

 

轻量级锁

轻量级锁加锁

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

 

轻量级锁解锁

     轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。下图是两个线程同时争夺锁，导致锁膨胀的流程图。

 

     因为自旋锁会消耗CPU，为了避免无用的自旋【获得锁的线程被阻塞住】，升级成为重量级锁。

 

锁的优缺点对比

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

 

 

 原子操作的实现和原理

         原子(atomic)是指“不能被进一步分割的最小粒子”，而原子操作(atomic operation)意为“不可被中断的一个或一系列操作”。在多处理器上实现原子操作就变得有点复杂。

CPU术语定义

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

 

 处理器如何实现原子操作

        32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理之间原子操作。

总线锁保证原子性

        如果多个处理器同时对共享变量进行读改写操作(i++就是经典的读改写操作)，那么共享变量就会被多个处理器同时进行操作，多个处理器同时从各自的缓存中读取变量i,分别进行加1操作，然后分别写入系统内存中，这样的操作不是原子操作，就不能得到期望的结果。

        处理器使用总线锁来解决这个问题，所谓总线锁就是使用处理器提供的一个LOCK #信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。

 

缓存锁保证原子性

          在同一时刻，只需要保证对某个内存地址的操作是原子性即可，但总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处理不能操作其他内存地址数据，所以总线锁的开销比较大。目前处理器在某些场景下使用缓存锁定代替总线锁定来进行优化。

 

使用CAS实现原子操作

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

public class CasMain {

	private AtomicInteger counter = new AtomicInteger(0);
	private int i = 0;

	public static void main(String[] args) {
		final CasMain cas = new CasMain();
		List<Thread> ts = new ArrayList<Thread>(600);
		long start = System.currentTimeMillis();
		for (int i = 0; i < 100; i++) {
			Thread t = new Thread(new Runnable() {
				@Override
				public void run() {
					for (int j = 0; j < 10000; j++) {
						cas.count();
						cas.safeCount();
					}
				}
			});
			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.counter.get());
		System.out.println("cost=" + (System.currentTimeMillis() - start)+ "ms");
	}

	private void safeCount() {
		for (;;) {
			int i = counter.get();
			boolean suc = counter.compareAndSet(i, ++i);
			if (suc) {
				break;
			}
		}
	}

	private void count() {
		i++;
	}
}

 

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

          在java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作，虽然原子操作很搞笑的解决了原子操作，但是CAS仍然存在三大问题。

 

 ABA问题

       因为CAS需要在操作指的时候检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时就会发现它的值没有变化，实际上是变化了。ABA问题的解决思路是使用版本号。在变量前面追加上版本号，每次变量更新时候就把版本号加1，那么A->B->A就会变成1A->2B->3A.JDK的Atomic包里面提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查大年引用是否等于预期引用，并且检查当前标志是否等于预测标志，如果全部相等，则以原子方式将该引用和标志的值设置为给定的更新值。

/**
     * Atomically sets the value of both the reference and stamp
     * to the given update values if the
     * current reference is {@code ==} to the expected reference
     * and the current stamp is equal to the expected stamp.
     *
     * @param expectedReference the expected value of the reference
     * @param newReference the new value for the reference
     * @param expectedStamp the expected value of the stamp
     * @param newStamp the new value for the stamp
     * @return {@code true} if successful
     */
    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流水线被清空（CPU Pipeline Flush），从而提高CPU的执行效率。

 

只能保证一个共享变量的原子操作

        当对一个共享变量执行操作时，我们可以使用循环CAS的方式保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。另外一个办法是合并成一个共享变量来操作。比如：两个变量i=2，j=a，合并为ij=2a，然后使用AtomicReferrence类来保证对象之间的原子性，就实现了多个变量放在一个对象里进行CAS操作。