一 synchronized加锁原理
synchronized可以保证方法或者代码块在运行时，同一时刻只有一个线程可以进入到临界区，同时它还可以保证共享变量的内存可见性。
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
（1）普通同步方法，锁是当前实例对象
（2）静态同步方法，锁是当前类的class对象
（3）同步方法块，锁是括号里面的对象
当一个线程访问同步代码块时，它首先是需要得到锁才能执行同步代码，当退出或者抛出异常时必须要释放锁，那么它是如何来实现这个机制的呢？我们先看一段简单的代码：
public class SynchronizedTest { public synchronized void test1(){ } public void test2(){ synchronized (this){ } } }
利用javap工具查看生成的class文件信息来分析Synchronize的实现如下图：
从上图可以看出，同步代码块是使用monitorenter和monitorexit指令实现的，同步方法依靠的是方法修饰符上的ACC_SYNCHRONIZED实现。
同步代码块：monitorenter指令插入到同步代码块的开始位置，monitorexit指令插入到同步代码块的结束位置，JVM需要保证每一个monitorenter都有一个monitorexit与之相对应。任何对象都有一个monitor与之相关联，当且一个monitor被持有之后，他将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象所对应的monitor所有权，即尝试获取对象的锁；
同步方法：synchronized方法则会被翻译成普通的方法调用和返回指令如：invokevirtual、areturn指令，在JVM字节码层面并没有任何特别的指令来实现被synchronized修饰的方法，而是在Class文件的方法表中将该方法的access_flags字段中的synchronized标志位置1，表示该方法是同步方法并使用调用该方法的对象或该方法所属的Class在JVM的内部对象表示Klass做为锁对象。
Java对象头和monitor是实现synchronized的基础！下面就这两个概念来做详细介绍。
二 Java对象头
synchronized用的锁是存在Java对象头里的，那么什么是Java对象头呢？Hotspot虚拟机的对象头主要包括两部分数据：Mark Word（标记字段）、Klass Pointer（类型指针）。其中Klass Point是对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，Mark Word用于存储对象自身的运行时数据，它是实现轻量级锁和偏向锁的关键，所以下面将重点阐述
Mark Word：
Mark Word用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等等。Java对象头一般占有两个机器码（在32位虚拟机中，1个机器码等于4字节，也就是32bit），但是如果对象是数组类型，则需要三个机器码，因为JVM虚拟机可以通过Java对象的元数据信息确定Java对象的大小，但是无法从数组的元数据来确认数组的大小，所以用一块来记录数组长度。下图是Java对象头的存储结构（32位虚拟机）：
对象头信息是与对象自身定义的数据无关的额外存储成本，但是考虑到虚拟机的空间效率，Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据，它会根据对象的状态复用自己的存储空间，也就是说，Mark Word会随着程序的运行发生变化，变化状态如下（32位虚拟机）：
简单介绍了Java对象头，我们下面再看Monitor。
Monitor
什么是Monitor？我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。
与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中 ，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁。
Monitor 是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。其结构如下：
Owner：初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL；
EntryQ:关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。
RcThis:表示blocked或waiting在该monitor record上的所有线程的个数。
Nest:用来实现重入锁的计数。
HashCode:保存从对象头拷贝过来的HashCode值（可能还包含GC age）。
Candidate:用来避免不必要的阻塞或等待线程唤醒，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。
三 锁优化
JDK1.6对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术来减少锁操作的开销。
锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
1 自旋锁
由于线程的阻塞和唤醒需要CPU从用户态转为内核态，因此频繁的阻塞和唤醒线程对CPU来说是一件负担很重的工作，势必会给系统的并发性能带来很大的压力。同时我们发现在许多应用上面，对象锁的锁状态只会持续很短一段时间，为了这一段很短的时间频繁地阻塞和唤醒线程是非常不值得的。所以引入自旋锁。
所谓自旋锁，就是让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。怎么等待呢？执行一段无意义的循环即可（自旋，for(;;)）。
自旋等待不能替代阻塞，虽然它可以避免线程切换带来的开销，但是它占用了处理器的时间。
如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理器的资源，它不会做任何有意义的工作，这样反而会带来性能上的浪费。所以说，自旋等待的时间（自旋的次数）必须要有一个限度，如果自旋超过了定义的时间仍然没有获取到锁，则应该被挂起。
自旋锁在JDK 1.4.2中引入，默认关闭，但是可以使用-XX:+UseSpinning开开启，在JDK1.6中默认开启。同时自旋的默认次数为10次，可以通过参数-XX:PreBlockSpin来调整；
如果通过参数-XX:preBlockSpin来调整自旋锁的自旋次数，会带来诸多不便。假如我将参数调整为10，但是系统很多线程都是等你刚刚退出自旋的时候就释放了锁（例如你多自旋一两次就可以获取锁）。于是JDK1.6引入自适应的自旋锁，让虚拟机会变得越来越聪明。
2 自适应自旋锁
JDK 1.6引入了自适应自旋锁。所谓自适应就意味着自旋的次数不再是固定的，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。
线程如果自旋加锁成功了，那么增加下一次自旋的次数，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。
有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明。
3 锁消除
参考：逃逸分析 https://www.cnblogs.com/aiqiqi/p/10650394.html
为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，JVM检测到不可能存在共享数据竞争，这时JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。
如果不存在竞争，为什么还需要加锁呢？所以锁消除可以节省毫无意义的请求锁的时间。有时候虽然没有显示使用锁，但是我们在使用一些JDK的内置API时，如StringBuffer、Vector、HashTable等，这个时候会存在隐形的加锁操作。比如StringBuffer的append()方法，Vector的add()方法：
public void vectorTest(){ Vector<String> vector = new Vector<String>(); for(int i = 0 ; i < 10 ; i++){ vector.add(i + ""); } System.out.println(vector); }
在运行这段代码时，JVM可以明显检测到变量vector没有逃逸出方法vectorTest()之外，所以JVM可以大胆地将vector内部的加锁操作消除。
4 锁粗化
在使用同步锁的时候，需要让同步块的作用范围尽可能小，仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。
但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗化的概念。
锁粗化概念比较好理解，就是将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁。如上面实例：vector每次add的时候都需要加锁操作，JVM检测到对同一个对象（vector）连续加锁、解锁操作，会合并一个更大范围的加锁、解锁操作，即加锁解锁操作会移到for循环之外。
5 轻量级锁
引入轻量级锁的主要目的是在多没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。当关闭偏向锁功能或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁，则会尝试获取轻量级锁，其步骤如下：
获取锁
（1）判断当前对象是否处于无锁状态（hashcode、0、01），若是，则JVM首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝（官方把这份拷贝加了一个Displaced前缀，即Displaced Mark Word）；否则执行步骤（3）；
（2）JVM利用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，如果成功表示竞争到锁，则将锁标志位变成00（表示此对象处于轻量级锁状态），执行同步操作；如果失败则执行步骤（3）；
（3）判断当前锁对象的Mark Word是否指向当前线程的栈帧，如果是则表示当前线程已经持有当前对象的锁，则直接执行同步代码块；否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁需要膨胀为重量级锁，锁标志位变成10，后面等待的线程将会进入阻塞状态；
释放锁
轻量级锁的释放也是通过CAS操作来进行的，主要步骤如下：
（1）取出在获取轻量级锁保存在栈帧Displaced Mark Word中的数据；
（2）用CAS操作将取出的数据替换当前对象的Mark Word中，如果成功，则说明释放锁成功，否则执行（3）；
（3）如果CAS操作替换失败，说明有其他线程尝试获取该锁，则需要在释放锁的同时需要唤醒被挂起的线程。
对于轻量级锁，其性能提升的依据是“对于绝大部分的锁，在整个生命周期内都是不会存在竞争的”，如果打破这个依据则除了互斥的开销外，还有额外的CAS操作，因此在有多线程竞争的情况下，轻量级锁比重量级锁更慢；
（6）偏向锁
引入偏向锁主要目的是：为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径。上面提到了轻量级锁的加锁解锁操作是需要依赖多次CAS原子指令的。那么偏向锁是如何来减少不必要的CAS操作呢？我们可以查看Mark work的结构就明白了。只需要检查是否为偏向锁、锁标识为以及ThreadID即可，处理流程如下：
获取锁
（1）检测Mark Word是否为可偏向状态，即是否为偏向锁1，锁标识位为01；
（2）若为可偏向状态，则测试线程ID是否为当前线程ID，如果是，则执行步骤（5），否则执行步骤（3）；
（3）如果线程ID不为当前线程ID，则通过CAS操作竞争锁，竞争成功，则将Mark Word的线程ID替换为当前线程ID，否则执行线程（4）；
（4）通过CAS竞争锁失败，证明当前存在多线程竞争情况，当到达全局安全点，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码块；
（5）执行同步代码块
释放锁
偏向锁的释放采用了一种只有竞争才会释放锁的机制，线程是不会主动去释放偏向锁，需要等待其他线程来竞争。偏向锁的撤销需要等待全局安全点（这个时间点是上没有正在执行的代码）。其步骤如下：
（1）暂停拥有偏向锁的线程，判断锁对象石是否还处于被锁定状态；
（2）撤销偏向锁，恢复到无锁状态（01）或者轻量级锁的状态；
（7）重量级锁
重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。
四 synchronized加锁分析
synchronized能够锁当前对象，也能够锁类。
synchronized锁住当前对象的写法：
public synchronized void a(){ do somesing... } public void ab(){ synchronized (this){ do somesing... }
}
synchronized锁住当前类对象的写法：
public synchronized static void a(){ do somesing... } public static void a(){ synchronized (类名){ do somesing... } } public void ab(){ synchronized (类名){ do somesing... } }
当synchronized作用在对象时候，同一个对象中的线程是相互排斥的，仅仅有一个线程运行完毕后。另外一个线程才干获得对象锁得到运行。如果不是同一个对象，则不会产生相互排斥 。
当synchronized作用在类时，对于同一个jvm中不同对象的多个线程调用同一个synchronized修饰的方法都是相互排斥的。由于一个jvm仅仅会为一个class文件产生同一个class对象。
类锁实际上用对象锁来实现。当虚拟机装载一个class文件的时候，它就会创建一个java.lang.Class类的实例对象。当锁住一个类（synchronized (类名)）的时候，实际上锁住的是那个类的Class对象。
synchronized支持可重入性，一个线程可以多次对同一个对象上锁。对于每一个对象，java虚拟机维护一个加锁计数器，线程每获得一次该对象，计数器就加1，每释放一次，计数器就减 1，当计数器值为0时，锁就被完全释放了。
五 不同锁的MarkWord详细说明
1 无锁状态
在创建一个Object时，这时没有任何同步代码块锁这个对象，这时这个锁的Mark word格式如下：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }
由于是小端表示法，因此，实际Mark word头里的数据是：00000000 00000000 00000000 00000001 ，能看出实际在无锁状态下，锁标志位为01，但是hashCode位都是0，这是因为对象的hashCode计算是懒计算的，只有在调用了hashCode方法时才会计算hashCode并存到对象头里：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); o.hashCode(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }
2 偏向锁
如果有一个线程对object对象进行加锁，会优先设置偏向锁：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { TimeUnit.SECONDS.sleep(5); Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); synchronized (o){ System.out.println(ClassLayout.parseInstance(o).toPrintable()); } } }
可以看下加锁后的对象的MarkWork：00000101 01001000 00100100 00000011，按照大端展示调整后为：00000011 00100100 01001000 00000101，可以看出锁标志位01位偏向锁，前面为偏向线程ID。
但是看下无锁时对象的MarkWord：00000101 00000000 00000000 00000000，按照大端展示调整后为：00000000 00000000 00000000 00000101，可以发现竟然也是偏向锁，这是因为给对象加了一个伪偏向锁的标记，表示当前对象可以加偏向锁。
同时可以看出在代码里先休眠了5秒，这是因为JVM中，偏向锁是懒启动的，需要在一段时间后开启偏向锁。这是因为在JVM启动的时候会进行很多加锁操作，为了防止频繁的偏向锁向轻量级锁的升级，就暂时不开启偏向锁。
3 轻量级锁
如果多个线程交替对对象加锁，线程之间没有竞争关系，这时会对对象加轻量级锁：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { TimeUnit.SECONDS.sleep(5); Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); new Thread(()->{ synchronized (o){ System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }).start(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); TimeUnit.SECONDS.sleep(3); new Thread(()->{ synchronized (o){ System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }).start(); } }
另外，如果在加锁之前，获取了对象的hashCode，那么会直接对对象加轻量级锁：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { TimeUnit.SECONDS.sleep(5); Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); o.hashCode(); synchronized (o) { System.out.println(ClassLayout.parseInstance(o).toPrintable()); } } }
这是因为，因此如果获取了对象的hashCode，就会设置到对象头里，但是偏向锁的MarkWord里是没法存对象的hashCode的，因此会直接加轻量级锁，因为轻量级锁会把对象头的MarkWord存储到线程栈的Lock Record里。
4 重量级锁
如果多个线程竞争式的对对象加锁，则会升级为重量级锁：
public class ObjectSize { public static void main(String[] args) throws InterruptedException { TimeUnit.SECONDS.sleep(5); Object o = new Object(); System.out.println(ClassLayout.parseInstance(o).toPrintable()); Thread thread = new Thread(()->{ synchronized (o){ try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }); Thread thread1 = new Thread(()->{ synchronized (o){ System.out.println(ClassLayout.parseInstance(o).toPrintable()); } }); thread.start(); thread1.start(); thread.join(); thread1.join(); } }
重量级锁的hashCode会存储到monitor里。
五 Synchronized和Lock的区别
1. 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
2. synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
3. synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
4. 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
5. synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可中断、可公平（两者皆可）
6. Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
7. Lock能提高多个线程读操作的效率。
7. synchronized能锁住类、方法和代码块，而Lock是块范围内的
