1 锁优化历史

synchronized 从 JDK1.0到JDK1.5   
    
    
 ，效率低 JDK1.5到JDK1.6

     


     


     ，JVM团队对synchronized进行深度优化 




 




 




，加入了：适应性自旋  
    
    
 、锁消除

     


     


     、锁膨胀 




 




 




、轻量级锁  

   

   

、偏向锁 等优化技术 JDK1.5 开始  

   

   

，加入java.util.concurrent

     

     

     ，提供API层面的轻量级锁应用

为什么优化synchronized？

互斥同步对性能最大的影响是阻塞的实现  




  




  



，挂起线程和恢复线程的操作都需要转入内核态中完成  


  


  


，这些操作给Java虚拟机的并发性能带来了很大的压力  
    
    
 。

2 自旋锁与自适应自旋

2.1 关于自旋锁

自旋锁历史进程：首次出现在JDK1.4.2
     
     
    ，但默认关闭(使用-XX：+UseSpinning参数开启)
   




   




   


，在JDK6开始默认开启

     


     


     。

自旋锁实现逻辑：如果锁被其它线程占有 



 



 



，那么本线程不放弃处理器的执行时间              ，并执行一个忙循环（自旋）

    




    




    

，直至得到锁 




 




 




。

自旋锁弊端：如果锁被占用的时间很长














，那么自旋的线程只会白白消耗处理器资源              ，带来性能的浪费

自旋锁优化：

引入自旋次数：如果自旋超过了限定的次数仍然没有成功获得锁

     



     



     
，就应当使用传统的方式去挂起线程  

   

   

。自旋次数的默认值是10次














，可以启用参数-XX：PreBlockSpin来更改

     

     

     。（次数在JDK1.4.2已经实现） 引入了自适应自旋

2.1 自旋锁优化：自适应自旋

原来：所有线程的自旋时间统一的（PreBlockSpin配置值 * 单次自旋时间）

自适应自旋：自旋的时间不固定  
    
    
 ，JVM根据前一次在同一个锁上的自旋时间及锁的拥有者的状态

来决定  




  




  



。

自适应自旋情形： 例如1：线程A

     

     

     、B

     


     


     ，锁L  


  


  


。A先通过自旋获取锁 




 




 




，那么JVM认为B也能通过自旋获取到锁  

   

   

，随即给B分配自旋时间

     

     

     ，并且这个时间也是综合之前的自旋时间 例如2：锁L  




  




  



，线程A B C 通过自旋  


  


  


，都没有获取到锁
     
     
    ，那么JVM会对后续的线程省略自旋过程
   




   




   


，以免浪费处理器资源

3 锁消除

定义：指虚拟机即时编译器在运行时 



 



 



，对一些代码要求同步              ，但是对被检测到不可能存在共享数据竞争的锁进行消除
     
     
    。

判断依据：源于逃逸分析的数据支持

    




    




    

，如果判断到一段代码中














，在堆上的所有数据都不会逃逸出去被其他线程访问到              ，那就可以把它们当作栈上数据对待

     



     



     
，认为它们是线程私有的














，同步加锁自然就无须再进行
   




   




   


。

举例：

一段看起来没有同步的代码：

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

javac编译后  
    
    
 ，会变为以下同等代码：

public String concatString(String s1, String s2, String s3) { StringBuffer sb = new StringBuffer(); sb.append(s1); sb.append(s2); sb.append(s3); return sb.toString(); } //append()方法有synchronize修饰

分析：

jvm观察变量sb

     


     


     ，经过逃逸分析后会发现它的动态作用域被限制在concatString()方法内部 



 



 



。可以采用无锁操作              。

在解释执行时这里仍然会加锁 




 




 




，但在即时编译之后  

   

   

，这段代码就会忽略所有的同步措施而直接执行

    




    




    

。

锁消除总结：

JVM会进行逃逸分析

     

     

     ，符合条件的  




  




  



，在编译为机器码时  


  


  


，会消除所有同步措施

4 锁粗化

定义：假如一串零碎的操作都对同一个对象加锁
     
     
    ，JVM会把加锁同步的范围扩展（粗化）到整个操作序列的外部

举例：

例如上面concatString()方法
   




   




   


，将锁扩展到第一个append()操作之前最后一个append()操作之后 



 



 



，这样只需加锁一次

5 轻量级锁

逻辑：无竞争的情况下使用CAS操作去消除同步使用的互斥量

轻量级锁提升性能的依据：“对于绝大部分的锁              ，在整个同步周期内都是不存在竞争的  
    
    
 ”这一经验法则

过程分析：后续补充

6 偏向锁

逻辑：在无竞争的情况下把整个同步都消除掉

    




    




    

，连CAS操作都不去做

“偏

     


     


     ”的理解：锁会偏向于第一个获得它的线程














，如果在接下来的执行过程中              ，该锁一直没有被其他的线程获取

     



     



     
，则持有偏向锁的线程将永远不需要再进行同步














。

过程分析：后续补充