synchronized

1当synchronized作用在实例方法时，监视器锁（monitor）便是对象实例（this）；
2当synchronized作用在静态方法时，监视器锁（monitor）便是对象的Class实例，因为Class数据存在于永久代，因此静态方法锁相当于该类的一个全局锁；
3当synchronized作用在某一个对象实例时，监视器锁（monitor）便是括号括起来的对象实例；

1原子性：确保线程互斥的访问同步代码；
2可见性：保证共享变量的修改能够及时可见，其实是通过Java内存模型中的 “对一个变量unlock操作之前，必须要同步到主内存中；如果对一个变量进行lock操作，则将会清空工作内存中此变量的值，在执行引擎使用此变量前，需要重新从主内存中load操作或assign操作初始化变量值” 来保证的；
3有序性：有效解决重排序问题，即 “一个unlock操作先行发生(happen-before)于后面对同一个锁的lock操作”；
从语法上讲，Synchronized可以把任何一个非null对象作为"锁"，在HotSpot JVM实现中，锁有个专门的名字：对象监视器（Object Monitor）。 

注意，synchronized 内置锁 是一种 对象锁（锁的是对象而非引用变量），作用粒度是对象 ，可以用来实现对 临界资源的同步互斥访问 ，是 可重入 的。其可重入最大的作用是避免死锁，如：

子类同步方法调用了父类同步方法，如没有可重入的特性，则会发生死锁；
如果一个线程A调用一个实例对象的非static synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁

本篇我们讲通过大量实例代码及hotspot源码分析偏向锁(批量重偏向、批量撤销)、轻量级锁、重量级锁及锁的膨胀过程（也就是锁的升级过程）。

为什么需要锁

因为在并发情况为了保证线程的安全性，是在一个多线程环境下正确性的概念，也就是保证多线程环境下共享的、可修改的状态的正确性（这里的状态指的是程序里的数据），在java程序中我们可以使用synchronized关键字来对程序进行加锁。
当声明synchronized代码块的时候，编译成的字节码将包含monitorenter指令 和 monitorexit指令。这两种指令均会消耗操作数栈上的一个引用类型的元素（也就是 synchronized 关键字括号里的引用），作为所要加锁解锁的锁对象。
（注意：jdk 1.6以前synchronized 关键字只表示重量级锁，1.6之后区分为偏向锁、轻量级锁、重量级锁。）

所谓锁的升级、降级，就是 JVM 优化 synchronized 运行的机制，当 JVM 检测到不同的竞争状况时，会自动切换到适合的锁实现，这种切换就是锁的升级、降级：

●当没有竞争出现时，默认会使用偏向锁。JVM 会利用 CAS 操作（compare and swap），在对象头上的 Mark Word 部分设置线程 ID，以表示这个对象偏向于当前线程，所以并不涉及真正的互斥锁。这样做的假设是基于在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏向锁可以降低无竞争开销。

●如果有另外的线程试图锁定某个已经被偏向过的对象，JVM 就需要撤销（revoke）偏向锁，并切换到轻量级锁实现。轻量级锁依赖 CAS 操作 Mark Word 来试图获取锁，如果重试成功，就使用轻量级锁；否则，进一步升级为重量级锁

 我们可以抽象的理解为每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针：

●当执行 monitorenter 时，如果目标锁对象的计数器为 0，那么说明它没有被其他线程所持有。在这个情况下，Java 虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加 1。

●在目标锁对象的计数器不为 0 的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将其计数器加 1，否则需要等待，直至持有线程释放该锁。当执行 monitorexit 时，Java 虚拟机则需将锁对象的计数器减 1。当计数器减为 0 时，那便代表该锁已经被释放掉了。

●之所以采用这种计数器的方式，是为了允许同一个线程重复获取同一把锁。举个例子，如果一个 Java 类中拥有多个 synchronized 方法，那么这些方法之间的相互调用，不管是直接的还是间接的，都会涉及对同一把锁的重复加锁操作。因此，我们需要设计这么一个可重入的特性，来避免编程里的隐式约束。 

 偏向锁、轻量级锁、重量级锁及锁的膨胀过程

无锁状态

　开始时应该这样的，线程A和线程B要去争抢锁对象，但还未开始争抢，锁对象的对象头是无锁的状态也就是25bit位存的hashCode，4bit位存的对象的分代年龄，1bit位记录是否为偏向锁，2bit位记录状态，优先看最后2bit位，是01，所以说我们的对象可能无锁或者偏向锁状态的，继续前移一个位置，有1bit专门记录是否为偏向锁的，1代表是偏向锁，0代表无锁，刚刚开始的时候一定是一个无锁的状态，这个不需要多做解释，系统不同内部bit位存的东西可能有略微差异，但关键信息是一致的。

偏向锁

这时线程开始占有锁对象，比如线程A得到了锁对象。

​ 线程A拿到锁对象，将我们的偏向锁标志位改为1，并且将原有的hashCode的位置变为23bit位存放线程A的线程ID（用CAS算法得到的线程A的ID），2bit位存epoch，偏向锁是永远不会被释放的。
​
　　接下来，线程B也开始运行，线程B也希望得到这把锁啊，于是线程B会检查23bit位存的是不是自己的线程ID，因为被线程A已经持有了，一定锁的23bit位一定不是线程B的线程ID了。

　然后线程B也会不甘示弱，会尝试修改一次23bit位的对象头存储，如果说这时恰好线程A释放了锁，可以修改成功，然后线程B就可以持有该偏向锁了。

　如果修改失败，开始升级锁。自己无法修改，线程B只能找“大哥”了，线程B会通知虚拟机撤销偏向锁，然后虚拟机会撤销偏向锁，并告知线程A到达安全点进行等待。线程A到达了安全点，会再次判断线程是否已经退出了同步块，如果退出了，将23bit位置空，这时锁不需要升级，线程B可以直接进行使用了，还是将23bit的null改为线程B的线程ID就可以了。

轻量级锁

如果线程B没有拿到锁，我们就会升级到轻量级锁，首先会在线程A和线程B都开辟一块LockRecord空间，然后把锁对象复制一份到自己的LockRecord空间下，并且开辟一块owner空间留作执行锁使用，并且锁对象的前30bit位合并，等待线程A和线程B来修改指向自己的线程，假如线程A修改成功，则锁对象头的前30bit位会存线程A的LockRecord的内存地址，并且线程A的owner也会存一份锁对象的内存地址，形成一个双向指向的形式。而线程B修改失败，则进入一个自旋状态，就是持续来修改锁对象。

 重量级锁

如果说线程B多次自旋以后还是迟迟没有拿到锁，他会继续上告，告知虚拟机，我多次自旋还是没有拿到锁，这时我们的线程B会由用户态切换到内核态，申请一个互斥量，并且将锁对象的前30bit指向我们的互斥量地址，并且进入睡眠状态，然后我们的线程A继续运行直到完成时，当线程A想要释放锁资源时，发现原来锁的前30bit位并不是指向自己了，这时线程A释放锁，并且去唤醒那些处于睡眠状态的线程，锁升级到重量级锁。