synchronized 关键字

1. synchronized 特点

1.1 简介

Synchronized 是基于 monitor 实现的,Synchronized 经过编译后，会在同步块前后分别形成 monitorenter 和 monitorexit 两个字节码指令，在执行 monitorenter 指令时，首先要尝试获取对象锁，如果对象没有别锁定，或者当前已经拥有这个对象锁，把锁的计数器加 1，相应的在执行 monitorexit 指令时，会将计数器减 1，当计数器为 0 时，锁就被释放了。

如果获取锁失败，那当前线程就要阻塞，直到对象锁被另一个线程释放为止。

synchronized 底层语义原理

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步都是如此。在 Java 语言中，同步用的最多的地方可能是被 synchronized 修饰的同步方法。

同步方法 并不是由 monitorenter 和 monitorexit 指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的，关于这点，稍后详细分析。下面先来了解一个概念 Java 对象头，这对深入理解 synchronized 实现原理非常关键。

1.2 特点

• 可重入锁

• 排他锁

• 属于 jvm，由 jvm 实现

可重入锁实现可重入性原理或机制是：

每一个锁关联一个线程持有者和计数器，当计数器为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；

当某一线程请求成功后，JVM 会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁。

1.3 synchronized 保证可见性

JMM 关于 synchronized 的两条规定：

• 1）线程解锁前，必须把共享变量的最新值刷新到主内存中

• 2）线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新获取最新的值

1.4 synchronized 保证可见性

HashTable

2. JVM 对 Synchronized 的优化

锁的状态总共有四种，无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级。

2.1 Java 对象头与 Monitor

在 JVM 中，对象在内存中的布局分为三块区域：对象头、实例数据和对齐填充。如下：

• 实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按 4 字节对齐。

• 填充数据：由于虚拟机要求对象起始地址必须是 8 字节的整数倍。填充数据不是必须存在的，仅仅是为了字节对齐，这点了解即可。

Java 对象头

Java 头对象，它实现 synchronized 的锁对象的基础，synchronized 使用的锁对象是存储在 Java 对象头里的，jvm 中采用 2 个字来存储对象头(如果对象是数组则会分配 3 个字，多出来的 1 个字记录的是数组长度)，其主要结构是由 Mark Word 和 Class Metadata Address 组成，其结构说明如下表：

虚拟机位数     头对象结构                           说明32/64bit      Mark Word                存储对象的hashCode、锁信息或分代年龄或GC标志等信息32/64bit      Class Metadata Address   类型指针指向对象的类元数据，JVM通过这个指针确定该对象是哪个类的实例。

复制代码

其中 Mark Word 在默认情况下存储着对象的 HashCode、分代年龄、锁标记位等以下是 32 位 JVM 的 Mark Word 默认存储结构

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

复制代码

由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本，因此考虑到 JVM 的空间效率，Mark Word 被设计成为一个非固定的数据结构，以便存储更多有效的数据，它会根据对象本身的状态复用自己的存储空间，如 32 位 JVM 下，除了上述列出的 Mark Word 默认存储结构外，还有如下可能变化的结构：

2.2 java 重量级锁

【重量级锁】

说明：    1)java6之前的synchronized属于重量级锁，效率低下，因为monitor是依赖操作系统的Mutex Lock(互斥量)来实现的。    2)多线程竞争锁时，会引起线程的上下文切换(即在cpu分配的时间片还没有用完的情况下进行了上下文切换)。    3)操作系统实现线程的上下文切换需要从用户态转换到核心态，这个状态之间的转换需要相对较长的时间，时间成本相对较高。    4)在互斥状态下，没有得到锁的线程会被挂起阻塞，而挂起线程和恢复线程的操作都需要从用户态转入内核态中完成。
优点：线程竞争不使用自旋，不会消耗cpu。缺点：线程阻塞，响应时间缓慢。应用：追求吞吐量，同步块执行速度较长

复制代码

轻量级锁和偏向锁是 Java 6 对 synchronized 锁进行优化后新增加的，重量级锁也就是通常说 synchronized 的对象锁，锁标识位为 10，其中指针指向的是 monitor 对象（也称为管程或监视器锁）的起始地址。

每个对象都存在着一个 monitor 与之关联，对象与其 monitor 之间的关系有存在多种实现方式，如 monitor 可以与对象一起创建销毁或当线程试图获取对象锁时自动生成，但当一个 monitor 被某个线程持有后，它便处于锁定状态。

在 Java 虚拟机(HotSpot)中，monitor 是由 ObjectMonitor 实现的，其主要数据结构如下（位于 HotSpot 虚拟机源码 ObjectMonitor.hpp 文件，C++实现的）

ObjectMonitor() {    _header       = NULL;    _count        = 0; //记录个数    _waiters      = 0,    _recursions   = 0;    _object       = NULL;    _owner        = NULL;    _WaitSet      = NULL; //处于wait状态的线程，会被加入到_WaitSet    _WaitSetLock  = 0 ;    _Responsible  = NULL ;    _succ         = NULL ;    _cxq          = NULL ;    FreeNext      = NULL ;    _EntryList    = NULL ; //处于等待锁block状态的线程，会被加入到该列表    _SpinFreq     = 0 ;    _SpinClock    = 0 ;    OwnerIsThread = 0 ;  }

复制代码

ObjectMonitor 中有两个队列，_WaitSet 和 _EntryList，用来保存 ObjectWaiter 对象列表( 每个等待锁的线程都会被封装成 ObjectWaiter 对象)，_owner 指向持有 ObjectMonitor 对象的线程，当多个线程同时访问一段同步代码时。

首先会进入 _EntryList 集合，当线程获取到对象的 monitor 后进入_Owner 区域并把 monitor 中的 owner 变量设置为当前线程同时 monitor 中的计数器 count 加 1，若线程调用 wait() 方法，将释放当前持有的 monitor，owner 变量恢复为 null，count 自减 1，同时该线程进入 WaitSet 集合中等待被唤醒。

若当前线程执行完毕也将释放 monitor(锁)并复位变量的值，以便其他线程进入获取 monitor(锁)。如下图所示:

由此看来，monitor 对象存在于每个 Java 对象的对象头中(存储的指针的指向)，synchronized 锁便是

通过这种方式获取锁的，也是为什么 Java 中任意对象可以作为锁的原因，同时也是 notify/notifyAll/wait 等方法存在于顶级对象 Object 中的原因(关于这点稍后还会进行分析)

synchronized代码块底层原理

2.3 偏向锁

1)背景：大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。2)概念：核心思想就是锁会偏向第一个获取它的线程，如果在接下来的执行过程中没有其它的线程获取该锁，则持有偏向锁的线程永远不需要同步。3)目的：偏向锁实际上是一种优化锁，其目的是为了减少数据在无竞争情况下的性能损耗。4)原理：    1>当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID。    2>以后该线程在进入和退出同步块时就不需要进行CAS操作来加锁和解锁，只需简单地判断一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。5)偏向锁的获取：    1>访问Mark Word中偏向锁的标识位是否为1，如果是1，则确定为偏向锁。      说明：      [1]如果偏向锁的标识位为0，说明此时是处于无锁状态，则当前线程通过CAS操作尝试获取偏向锁，如果获取锁成功，则将Mark Word中的偏向线程ID设置为当前线程ID；并且将偏向标识位设为1。      [2]如果偏向锁的标识位不为1，也不为0(此时偏向锁的标识位没有值)，说明发生了竞争，偏向锁已经膨胀为轻量级锁，这时使用CAS操作尝试获得锁。    2>如果是偏向锁，则判断Mark Word中的偏向线程ID是否指向当前线程，如果偏向线程ID指向当前线程，则表明当前线程已经获取到了锁；    3>如果偏向线程ID并未指向当前线程，则通过CAS操作尝试获取偏向锁，如果获取锁成功，则将Mark Word中的偏向线程ID设置为当前线程ID；    4>如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点时(在这个时间点上没有正在执行的字节码)，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。6)偏向锁的释放：      1>当其它的线程尝试获取偏向锁时，持有偏向锁的线程才会释放偏向锁。      2>释放偏向锁需要等待全局安全点(在这个时间点上没有正在执行的字节码)。     3>过程：        首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程不处于活动状态，则将对象头设置成无锁状态，        如果线程还活着，说明此时发生了竞争，则偏向锁升级为轻量级锁，然后刚刚被暂停的线程会继续往下执行同步代码。7)优点：加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级的差距8)缺点：如果线程间存在锁竞争，锁撤销会带来额外的消耗。9)说明：    1)偏向锁默认在应用程序启动几秒钟之后才激活。    2)可以通过设置 -XX:BiasedLockingStartupDelay=0 来关闭延迟。    3)可以通过设置 -XX:-UseBiasedLocking=false 来关闭偏向锁，程序默认会进入轻量级锁状态。(如果应用程序里的锁大多情况下处于竞争状态，则应该将偏向锁关闭)

复制代码

2.4 轻量级锁

1)原理：    1>当使用轻量级锁(锁标识位为00)时，线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并将对象头中的Mark Word复制到锁记录中(注:锁记录中的标识字段称为Displaced Mark Word)。    2>将对象头中的MarkWord复制到栈桢中的锁记录中之后，虚拟机将尝试使用CAS将对象头中Mark Word替换为指向该线程虚拟机栈中锁记录的指针，此时如果没有线程占有锁或者没有线程竞争锁，则当前线程成功获取到锁，然后执行同步块中的代码。    3>如果在获取到锁的线程执行同步代码的过程中，另一个线程也完成了栈桢中锁记录的创建，并且已经将对象头中的MarkWord复制到了自己的锁记录中，然后尝试使用CAS将对象头中的MarkWord修改为指向自己的锁记录的指针，但是由于之前获取到锁的线程已经将对象头中的MarkWord修改过了(并且现在还在执行同步体中的代码,即仍然持有着锁)，所以此时对象头中的MarkWord与当前线程锁记录中MarkWord的值不同，导致CAS操作失败，然后该线程就会不停地循环使用CAS操作试图将对象头中的MarkWord替换为自己锁记录中MarkWord的值，(当循环次数或循环时间达到上限时停止循环)如果在循环结束之前CAS操作成功，那么该线程就可以成功获取到锁，如果循环结束之后依然获取不到锁，则锁获取失败，对象头中的MarkWord会被修改为指向重量级锁的指针，然后这个获取锁失败的线程就会被挂起，阻塞了。    4>当持有锁的那个线程执行完同步体之后，使用CAS操作将对象头中的MarkWord还原为最初的状态时(将对象头中指向锁记录的指针替换为Displaced Mark Word )，发现MarkWord已被修改为指向重量级锁的指针，因此CAS操作失败，该线程会释放锁并唤起阻塞等待的线程，开始新一轮夺锁之争，而此时，轻量级锁已经膨胀为重量级锁，所有竞争失败的线程都会阻塞，而不是自旋。    自旋锁：          1)所谓自旋锁，就是让没有获得锁的进程自己运行一段时间自循环(默认开启)，但是不挂起线程。          2)自旋的代价就是该线程会一直占用处理器如果锁占用的时间很短，自旋等待的效果很好，反之，自旋锁会消耗大量处理器资源。          3)因此，自旋的等待时间必须有一定限度，超过限度还没有获得锁，就要挂起线程。         优点：在没有多线程竞争的前提下，减少传统的重量级锁带来的性能损耗。  缺点：竞争的线程如果始终得不到锁，自旋会消耗cpu。  应用：追求响应时间，同步块执行速度非常快。 

复制代码

2.5 锁消除

概念：JVM 在 JIT 编译(即时编译)时，通过对运行上下文的扫描，去除掉那些不可能发生共享资源竞争的锁，从而节省了线程请求这些锁的时间。

举例：

StringBuffer 的 append 方法是一个同步方法，如果 StringBuffer 类型的变量是一个局部变量，则该变量就不会被其它线程所使用，即对局部变量的操作是不会发生线程不安全的问题。

在这种情景下，JVM 会在 JIT 编译时自动将 append 方法上的锁去掉。

2.6 锁粗化

概念：将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁，即将加锁的粒度放大。

举例：在 for 循环里的加锁/解锁操作，一般需要放到 for 循环外。

2.7 中断与 synchronized

事实上线程的中断操作对于正在等待获取的锁对象的 synchronized 方法或者代码块并不起作用，也就是对于 synchronized 来说，如果一个线程在等待锁，那么结果只有两种，要么它获得这把锁继续执行，要么它就保存等待，即使调用中断线程的方法，也不会生效。演示代码如下

public class SynchronizedBlocked implements Runnable{
    public synchronized void f() {        System.out.println("Trying to call f()");        while(true) // Never releases lock            Thread.yield();    }
    /**     * 在构造器中创建新线程并启动获取对象锁     */    public SynchronizedBlocked() {        //该线程已持有当前实例锁        new Thread() {            public void run() {                f(); // Lock acquired by this thread            }        }.start();    }    public void run() {        //中断判断        while (true) {            if (Thread.interrupted()) {                System.out.println("中断线程!!");                break;            } else {                f();            }        }    }

    public static void main(String[] args) throws InterruptedException {        SynchronizedBlocked sync = new SynchronizedBlocked();        Thread t = new Thread(sync);        //启动后调用f()方法,无法获取当前实例锁处于等待状态        t.start();        TimeUnit.SECONDS.sleep(1);        //中断线程,无法生效        t.interrupt();    }}

复制代码

我们在 SynchronizedBlocked 构造函数中创建一个新线程并启动获取调用 f()获取到当前实例锁，由于 SynchronizedBlocked 自身也是线程，启动后在其 run 方法中也调用了 f()，但由于对象锁被其他线程占用，导致 t 线程只能等到锁，此时我们调用了 t.interrupt();但并不能中断线程。

2.8 等待唤醒机制与 synchronized

所谓等待唤醒机制本篇主要指的是 notify/notifyAll 和 wait 方法，在使用这 3 个方法时，必须处于 synchronized 代码块或者 synchronized 方法中，否则就会抛出 IllegalMonitorStateException 异常，这是因为调用这几个方法前必须拿到当前对象的监视器 monitor 对象，也就是说 notify/notifyAll 和 wait 方法依赖于 monitor 对象，在前面的分析中，我们知道 monitor 存在于对象头的 Mark Word 中(存储 monitor 引用指针)，而 synchronized 关键字可以获取 monitor ，这也就是为什么 notify/notifyAll 和 wait 方法必须在 synchronized 代码块或者 synchronized 方法调用的原因。

synchronized (obj) {       obj.wait();       obj.notify();       obj.notifyAll();          }

复制代码

需要特别理解的一点是，与 sleep 方法不同的是 wait 方法调用完成后，线程将被暂停，但 wait 方法将会释放当前持有的监视器锁(monitor)，直到有线程调用 notify/notifyAll 方法后方能继续执行，而 sleep 方法只让线程休眠并不释放锁。同时 notify/notifyAll 方法调用后，并不会马上释放监视器锁，而是在相应的 synchronized(){}/synchronized 方法执行结束后才自动释放锁。

3. synchronized 不禁止指令重排序却能保证有序性

• synchronized 是排他锁，执行前加锁，执行完后释放，保证单线程执行

• 满足 as-if-serial 语义，保证单线程执行，单线程有序性天然存在

as-if-serial 语义：不管怎么重排序，单线程程序的执行结果不能被改变。