java 同步锁：synchronized 关键字

简介

synchronized关键字是Java里面最基本的同步手段，它经过编译之后，会在同步块的前后分别生成 monitorenter和 monitorexit字节码指令，这两个字节码指令都需要一个引用类型的参数来指明要锁定和解锁的对象；而直接使用 synchronized 关键字锁定方法时，生成的字节码指令里面并没有 monitorenter 和 monitorexit 这两个指令，而是为方法添加了一个flags: ACC_SYNCHRONIZED，该标识指明了该方法是一个同步方法。

两种用法

一、作用于方法上

public synchronized void method1(){
    System.out.println(1);
}

查看编译后的字节码，发现会在方法的中加入**ACC_SYNCHRONIZED**的标识：

public synchronized void method1();
      descriptor: ()V
      flags: (0x0021) ACC_PUBLIC, **ACC_SYNCHRONIZED**
      Code:
        stack=2, locals=1, args_size=1

二、作用于代码块

public void method3(){
    synchronized(this){
        System.out.println(3);
    }
}

查看编译后的字节码，发现会在同步块的前后分别生成 monitorenter和 monitorexit字节码指令

  public void method3();
          descriptor: ()V
          flags: (0x0001) ACC_PUBLIC
          Code:
            stack=2, locals=3, args_size=1
               0: aload_0
               1: dup
               2: astore_1
               3: **monitorenter**
               4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
               7: iconst_3
               8: invokevirtual #3                  // Method java/io/PrintStream.println:(I)V
              11: aload_1
              12: **monitorexit**
 ... 省略...

实现原理

在学习Java内存模型内存间的交互操作的时候，知道JAVA内存模型还提供了更大范围的原子性保证：lock和 unlock操作。

但是lock和 unlock操作并没有直接提供给用户使用，而是提供了更高层次的字节码指令 monitorenter和 monitorexit来隐式的使用lock和 unlock操作。

Lock（锁定）命令：把一个变量标识为一条线程独占的状态，作用于主内存的变量

unlock（解锁）命令：把处于锁定状态的变量释放锁，缩放锁后其他线程才可以锁定，作用于主内存的变量

而 synchronized 就是使用 monitorenter 和 monitorexit 这两个指令来实现锁的功能的。

根据JVM规范的要求，在执行monitorenter指令的时候，首先要去尝试获取对象的锁，如果这个对象没有被锁定，或者当前线程已经拥有了这个对象的锁，就把锁的计数器加1，相应地，在执行monitorexit的时候会把计数器减1，当计数器减小为0时，锁就释放了。所以 synchronized 对同一条线程来说是一个可重入的。

synchronized 同步块在已进入的线程执行完成之前，会阻塞后面的线程进入，而JAVA的线程是映射到操作系统的原生线程之上的，如果要阻塞或唤醒一个线程，都需要操作系统来帮忙完成，这就需要从用户态切换到内核态中，状态转换需要消耗很多的处理器时间，对与简单的同步块，状态转换消耗的时候可能比用户代码执行的时间还要长，所以 synchronized 是JAVA 语言中一个重量级的操作。

Java中的锁优化

高效并发是 JDK1.5 到JDK1.6 的一个重要改进，虚拟机在这个版本上实现了各种锁优化技术，比如：适应性自旋锁、锁消除、锁粗化、轻量级锁、偏向锁等，这些技术都是为了在线程之间更高效的共享数据，以及解决竞争问题。

自旋锁与自适应锁

同步(加锁)对性能最大的影响就是实现阻塞，挂起线程和恢复线程都需要转入到内核态完成，这会给系统的并发性带来很大的压力，然而有时候锁定状态只会维持很短的一段时间，为了这一小段时间去挂起和恢复线程并不值得。如果物理机上有一个以上的处理器，我们就可以让后面请求锁的那个线程多等待一会儿，但是并不放弃处理器的执行时间，看看持有锁的线程是否会很快就释放锁，为了让线程等待一会儿，我们只需要让线程执行一个忙循环(自旋操作)，这就是所谓的自旋锁。

自旋锁在 JDK1.4.2 中就已经引入，不过默认是关闭的，在 JDK1.6 中默认已经开启。自旋锁默认的自旋次数是 10 次，可以使用参数 -XX：PreBlockSpin 来更改。

自适应自旋锁是在 JDK1.6 中引入的。自适应的意思就是自旋的时间不再固定，而是由前一次在同一个锁上的自旋时间以及锁的拥有者的状态来决定的。如果在同一个锁对象上，自旋等待刚刚成功获取到锁，并且持有锁的线程正在运行中，那么虚拟机可能认为这次自旋可能会再次成功，进而允许自旋持续更长的时间，比如100个循环。如果对于某个锁，自旋很少成功获得锁，虚拟机之后可能会省略掉自旋的过程，以避免浪费处理器的资源。

锁消除

锁消除是指虚拟机在及时编译时，发现代码要求同步，但是却检测到不可能存在共享数据竞争的问题，从而进行锁消除。锁消除的主要判断依据来源于逃逸分析的数据支持，堆上的所有数据都不会逃逸出去被其他线程访问，就可以把它们当做栈上的数据对待，认为是线程私有的，自然无需通不加锁操作了。比如下面代码：

public String method(String s1, String s2,String s3){
		return s1 + s2 +s3;
}

上面代码在JDK 1.5 之后会转化为 StringBuffer 对象的连续 append 操作，转化后的代码为：

public String method(String s1, String s2,String s3){
		StringBuffer sb = new StringBuffer();
		sb.append(s1);
		sb.append(s2);
		sb.append(s3);
		return sb。toString();
}

在上面这段代码中，append() 方法中有一个同步块，锁就是sb对象，虚拟机观察就会发现sb 对象不会逃逸出方法，其他线程自然无法访问到，所以肯定是线程安全的，即便有锁，也是可以被安全的消除掉，在即时编译后，这段代码就会忽略所有的同步而直接执行了。

锁粗化

在原则上，我们在编写代码的时候，推荐将同步块的作用范围限制得尽量小。大部分的情况下，这种原则也是正确的，但是当存在一系列的连续操作都对同一个对象反复加锁和解锁，甚至是出现在循环中，即便没有线程竞争，也会出现不必要的性能开销，当检测到这种情况的时候，虚拟机就会把加锁同步的范围扩展(粗化)到整个操作序列的外部，以上面锁消除代码为例，就是扩展到第一个append() 操作之前和最后一个操作之后，这样只需要加一次锁就可以了。

轻量级锁

“轻量级”是相当于操作系统互斥量来实现的传统所而言的，因此传统锁又被称为“重量级锁”。要明白的是，轻量级锁并不是用来替代重量级锁的，它的本意是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的系统消耗。

对象头中的“Mark Word”是实现轻量级锁和偏向锁的关键，对象头分为两部分信息：一部分用于存储对象自身的运行数据，比如哈希码，GC分代年龄等，这部分数据的长度在 32 和 64 位的虚拟机中分别是 32bit 和 64 bit，这一部分就被成为“Mark Word”；另外一部分用于存储指向方法区对象类型数据的指针，如果是数组部分的话，还会有一个额外的部分用于存储数组长度。

Untitled

轻量级锁的加锁过程

在代码进入同步块的时候，如果此同步对象没有被锁定（锁标志位为“01”状态）
一: 虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，存锁对象目前的Mark Word内容的拷贝(也就是把对象头中的内容放入到当前线程的栈帧中去了).
二: 然后虚拟机使用CAS尝试把Mark Word的更新为指向锁记录（Lock Record）的引用地址, 如果更新成功了, 并修改MW的标志位为00, 代表该线程拿到了当前锁, 且处于轻量级的状态
三: 如果使用CAS更新失败了, 虚拟机会检查Mark Word的地址是否与当前线程一致, 不一致则说明是被其他线程拿到了锁, 一致则说明是当前线程拥有的锁, 可以继续执行同步代码块
如果有两条以上的线程争用同一个锁，那轻量级锁就不再有效，要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态

轻量级锁的解锁过程

锁对象的Mark Word仍然指向着线程的锁记录，那就用CAS操作把对象当前的Mark Word和线程中复制的Displaced Mark Word替换回来，如果替换成功，整个同步过程就完成了。如果替换失败，说明有其他线程尝试过获取该锁，那就要在释放锁的同时，唤醒被挂起的线程。

偏向锁

偏向锁的目的是消除数据在无竞争的情况下的同步原语，进一步提高程序的运行性能。如果是轻量级锁是在无竞争情况下使用 CAS 去消除同步使用的互斥量，那么偏向锁就是在无竞争的情况下把整个同步都消除掉，连 CAS 都不需要了。

偏向锁的“偏”，就是偏心的“偏”、偏袒的“偏”。它的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。

假设当前虚拟机启用了偏向锁（启用参数-XX:+UseBiasedLocking，这是JDK 1.6的默认值），那么，当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设为“01”，即偏向模式。同时使用 CAS 操作把获取到这个锁的线程的ID记录在对象的 Mark Word 之中，如果CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作

当有另外一个线程去尝试获取这个锁时，偏向模式就宣告结束。根据锁对象目前是否处于被锁定的状态，撤销偏向（Revoke Bias）后恢复到未锁定（标志位为“01”）或轻量级锁定（标志位为“00”）的状态，后续的同步操作就如上面介绍的轻量级锁那样执行

总结

（1）synchronized在编译时会在同步块前后生成monitorenter和monitorexit字节码指令或者ACC_SYNCHRONIZED的标识；

（2）monitorenter和monitorexit字节码指令需要一个引用类型的参数，基本类型不可以哦；

（3）monitorenter和monitorexit字节码指令更底层是使用Java内存模型的lock和unlock指令；

（4）synchronized是可重入锁；

（5）synchronized是非公平锁；

（6）synchronized可以同时保证原子性、可见性、有序性；

（7）synchronized有三种状态：偏向锁、轻量级锁、重量级锁；