关注微信公众号：程序猿的日常分享，定期更新分享。
在java中synchronized关键字是同步锁，他可以让我们的程序运行起来线程安全，屏蔽多线程带来的问题，实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
实现原理
Synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的。但是监视器锁本质又是依赖于底层的操作系统的互斥锁（Mutex Lock）来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。这种依赖于操作系统互斥锁（Mutex Lock）所实现的锁我们称之为“重量级锁”。
监视器锁（monitor）
当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，线程执行monitorexit就会释放monitor所有权。
monitorenter
执行 monitorenter 的线程尝试获得 monitor 的所有权，会发生以下这三种情况之一：
1、如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1。
3、如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
monitorexit
monitorexit 的作用是将 monitor 的计数器减 1，直到减为 0 为止。代表这个 monitor 已经被释放了，已经没有任何线程拥有它了，也就代表着解锁，所以，其他正在等待这个 monitor 的线程，此时便可以再次尝试获取这个 monitor 的所有权。
获取和释放监视器锁（monitor）
锁定代码块：
public class TestSync {
public void sync() {
synchronized (TestSync.class) {
System.out.println("test");
}
}
}
通过反编译看到如下代码：
public void sync();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: ldc #2 // class com/example/demo/test/TestSync
2: dup
3: astore_1
4: monitorenter
5: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
8: ldc #4 // String test
10: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
13: aload_1
14: monitorexit
15: goto 23
18: astore_2
19: aload_1
20: monitorexit
21: aload_2
22: athrow
23: return
从里面可以看出，synchronized 代码块实际上多了 monitorenter 和 monitorexit 指令，在第4、14、20行指令分别使用了 monitorenter 和 monitorexit。这里有一个 monitorenter，却有两个 monitorexit 指令的原因是，JVM 要保证每个 monitorenter 必须有与之对应的 monitorexit，monitorenter 指令被插入到同步代码块的开始位置，而 monitorexit 需要插入到方法正常结束处和异常处两个地方，这样就可以保证抛异常的情况下也能释放锁。
再来看一个添加到方法上的例子：
public class TestSync {
public static synchronized void syncStatic() {
}
}
反编译后的代码：
public static synchronized void syncStatic();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
Code:
stack=0, locals=0, args_size=0
0: return
在同步块中使用了monitorenter 和 monitorexit 指令，而同步方法则是依靠方法修饰符上的ACC_SYNCHRONIZED来完成的，无论哪种方式，本质上都是通过监视器锁（monitor）来完成的，在获取这个锁的过程中是排他的，也就是同一时间只能有一个线程获取到由synchronized所保护的对象监视器。
锁定的范围
synchronized可以被应用在方法上和代码块上，那么就存在几种情况：
1、synchronized加在普通方法上，则它取得的锁是当前对象。
2、synchronized加在一段代码块上，则它取得的锁是synchronized(Object)括号中的对象。
3、synchronized加在静态方法上，则它取得的锁是对类，该类所有的对象同一把锁。
锁优化
Java SE1.6对Synchronized进行了各种优化之后，它并不那么重了。在不同的场景中引入不同的锁优化。
1.偏向锁：适用于锁没有竞争的情况，假设共享变量只有一个线程访问。如果有其他线程竞争锁，锁则会膨胀成为轻量级锁。
2.轻量级锁：适用于锁有多个线程竞争，但是在一个同步方法块周期中锁不存在竞争，如果在同步周期内有其他线程竞争锁，锁会膨胀为重量级锁。
3.重量级锁：竞争激烈的情况下使用重量级锁。
偏向锁和轻量级锁之所以会在性能上比重量级锁是因为好，本质上是因为偏向锁和轻量级锁仅仅使用了CAS。
4.锁粗化:如果释放了锁，紧接着什么都没做，又重新获取锁，那么其实这种释放和重新获取锁是完全没有必要的，如果把同步区域扩大，也就是只在最开始加一次锁，并且在最后直接解锁。那么就可以把中间这些无意义的解锁和加锁的过程消除。如下代码：
public void lockCoarsening() {
synchronized (this) {
//do something
}
synchronized (this) {
//do something
}
synchronized (this) {
//do something
}
}
5.锁消除
在大多数情况下，方法只会在一个线程内被使用，如果编译器能确定这个方法只会在一个线程内被使用，就代表肯定是线程安全的，那么我们的编译器便会做出优化，把对应的 synchronized 给消除，省去加锁和解锁的操作，以便增加整体的效率。
6.自适应自旋锁
自旋就是通过不断的循环，不释放CPU资源，不断的尝试去获取锁，但是如果自旋的时间过长，那么性能开销就会很大，浪费了CPU的资源。
在 JDK 1.6 中引入了自适应的自旋锁来解决长时间自旋的问题。自适应意味着自旋的时间不再固定，而是会根据最近自旋尝试的成功率、失败率，以及当前锁的拥有者的状态等多种因素来共同决定。自旋的持续时间是变化的，自旋锁变“聪明”了。比如，如果最近尝试自旋获取某一把锁成功了，那么下一次可能还会继续使用自旋，并且允许自旋更长的时间；但是如果最近自旋获取某一把锁失败了，那么可能会省略掉自旋的过程，以便减少无用的自旋，提高效率。
关注微信公众号：程序猿的日常分享，定期更新分享。
网友评论