java锁优化的方法与思路。

小灰灰 2024-02-18 21:19 12阅读 0赞

java程序开发中一旦用到锁，就表示采用了阻塞形式的并发——一种最糟糕的[并发等级][Link 1]。而锁优化就是希望在高并发多线程程序当中将涉及到有锁动作的相关代码尽可能的加以改进，使执行效率尽可能地得到提升。当然就算将这种用到了锁的代码优化到极致，其性能也无法超越无锁，毕竟锁会导致线程挂起（相对来说相当耗时及浪费资源）。但是我们要想办法让这种损耗降到最低，这是锁优化的出发点。

一般来说，java锁优化有如下思路或方法：

*  减少锁持有时间
 *  减少锁粒度
 *  锁分离
 *  锁粗化
 *  锁消除

下面分别对锁优化的各种方法或思路作详细的介绍：

## 减少锁持有时间 ##

锁在同一时间只能允许一个线程持有，其它想要占用锁的线程都得在[临界区][Link 2]外等待锁的释放，这个等待的时间根据实际的应用及代码写法可长可短，比如下面的代码：

1.  `public synchronized void syncMethod(){`
2.  `noneLockedCode1();//不需要加锁的代码`
3.  `needLockedMethed();//需要线程安全的代码`
4.  `noneLockedCode2();//不需要加锁的代码`
5.  `}`

在syncMethod方法中调用了三个方法，每个方法各代表一段代码块，若其中只有一个方法needLockedMethed()需要线程安全，其它两个方法就没必要放到同步代码块内执行，那么就可以将上面的代码进行如下改进：

1.  `public void syncMethod(){`
2.  `noneLockedCode1();`
3.  `synchronized(this){`
4.  `needLockedMethed();`
5.  `}`
6.  `noneLockedCode2();`
7.  `}`

这样方法noneLockedCode1与noneLockedCode2的执行就不会占用锁的时间，减少了其它线程等待锁的时长，因此，也就提高了程序的性能，使锁的使用得到优化。

## 减少锁粒度 ##

加锁可能是针对一个很重的对象(对象会被很多个线程加锁），这时若**将大对象拆成更小粒度的小对象，就可以增加程序的并行度，降低多线程间锁的竞争，使加锁的成功率得到提**高，因而达到锁优化的目的。

关于减少锁粒度的一个重要例子ConcurrentHashMap的实现。

我们知道HashMap若要实现线程安全，可以这么做：`Collections.synchronizedMap(Map<K,V> m)`，该方法返回SynchronizedMap对象：

1.  `public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {`
2.  `return new SynchronizedMap<>(m);`
3.  `}`

它的实现也很简单，仅仅是将get与set方法进行了互斥的同步，实现代码如下：

1.  `public V get(Object key) {`
2.  `synchronized (mutex) {`
3.  `return m.get(key);`
4.  `}`
5.  `}`
6.  `public V put(K key, V value) {`
7.  `synchronized (mutex) {`
8.  `return m.put(key, value);`
9.  `}`
10. `}`

这样做会有什么问题？

这里的hashmap其实就是一个很重的对象，因为它里面可能会存储很多数据，当多个线程同时进来访问的时候，不管是读(get)还是写(put)，都要拿到互斥对(mutex)，因此读与写会相互阻塞，也就是说SynchronizedMap其实只支持对其中存放的一个对象进行读写，这无疑会带来很大的性能损耗，且map中数据越多、访问map的线程越多，损耗的性能就越大。

相对来讲，ConcurrentHashMap就是一个高性能的哈希表，这个高性能仅仅是因为它做了一个减小锁粒度的一个操作。在ConcurrentHashMap的源中，我们可以发现，它把整个Hashmap拆成了若干个小的segment,每一个segment都是一个小的hashmap,当有线程去操作里面的数据时，实时上操作的是被拆分后的某个小的segment,从而使ConcurrentHashMap允许多个线程同时进入，因此增加了并行度，达到了锁优化的目的。

## 锁分离 ##

如果对系统有读和写的要求，普通锁（如syncronized）会导致读阻塞写、写也会阻塞读，同时读读与写写之间也会进行阻塞，锁优化的目的是要想办法使得阻塞尽可能的小，这里读写锁就会起来一定的优化作用。

读写锁的基本思想是将读与写进行分离，因为读不会改变数据，所以读与读之间不需要进行同步，其它读写、写读、写写之间的情况如下表：

表中可以看出，只要有写锁进入就需要做同步处理，但是对于大多数应用来说，读的场景要远远大于写的场景，因此一旦使用读写锁，在读多写少的场景中，就可以很好的提高系统的性能，这就是锁分离。**锁分离之后在读锁与读锁之间就不再是阻塞的并发了，而是无等待的并发，这种锁优化方式将在一定场景下极大的提高系统的性能**。

锁分离在java中应用延伸的一个例子就是LinkedBlockingQueue：

![07cf641bd8d62a6f18140f24236028bd.PNG][]

它充分利用热点分离的思想，从头部拿数据(读)，添加数据(写)则在尾部，读与写这两者操作的数据在不同的部位，因此可以同时进行操作，使并发级别更高，除非队列或链表中只有一条数据。这就是读写分离思想的进一下延伸：**只要操作不相互影响，锁就可以分离。**

## 锁粗化 ##

通常情况下，为了保证多线程间的有效并发，会要求每个线程持有锁的时间尽可能短，但是大某些情况下，一个程序对同一个锁不间断、高频地请求、同步与释放，会消耗掉一定的系统资源，因为锁的讲求、同步与释放本身会带来性能损耗，这样高频的锁请求就反而不利于系统性能的优化了，虽然单次同步操作的时间可能很短。**锁粗化就是告诉我们任何事情都有个度，有些情况下我们反而希望把很多次锁的请求合并成一个请求，以降低短时间内大量锁请求、同步、释放带来的性能损耗。**

一种极端的情况如下：

1.  `public void doSomethingMethod(){`
2.  `synchronized(lock){`
3.  `//do some thing`
4.  `}`
5.  ``
6.  `//这是还有一些代码，做其它不需要同步的工作，但能很快执行完毕`
7.  ``
8.  `synchronized(lock){`
9.  `//do other thing`
10. `}`
11. `}`

上面的代码是有两块需要同步操作的，但在这两块需要同步操作的代码之间，需要做一些其它的工作，而这些工作只会花费很少的时间，那么我们就可以把这些工作代码放入锁内，将两个同步代码块合并成一个，以降低多次锁请求、同步、释放带来的系统性能消耗，合并后的代码如下:

1.  `public void doSomethingMethod(){`
2.  `//进行锁粗化：整合成一次锁请求、同步、释放`
3.  `synchronized(lock){`
4.  `//do some thing`
5.  `//做其它不需要同步但能很快执行完的工作`
6.  `//do other thing`
7.  `}`
8.  `}`

> 注意：这样做是有前提的，就是中间不需要同步的代码能够很快速地完成，如果不需要同步的代码需要花很长时间，就会导致同步块的执行需要花费很长的时间，这样做也就不合理了。

另一种需要锁粗化的极端的情况是：

1.  `for(int i=0;i<size;i++){`
2.  `synchronized(lock){`
3.  ``
4.  `}`
5.  `}`

上面代码每次循环都会进行锁的请求、同步与释放，看起来貌似没什么问题，且在jdk内部会对这类代码锁的请求做一些优化，但是还不如把加锁代码写在循环体的外面，这样一次锁的请求就可以达到我们的要求，除非有特殊的需要：循环需要花很长时间，但其它线程等不起，要给它们执行的机会。

锁粗化后的代码如下：

1.  `synchronized(lock){`
2.  `for(int i=0;i<size;i++){`
3.  ``  
    
4.  `}`
5.  `}`

## 锁消除 ##

锁消除是发生在编译器级别的一种锁优化方式。  
有时候我们写的代码完全不需要加锁，却执行了加锁操作。  
比如，StringBuffer类的append操作：

1.  `@Override`
2.  `public synchronized StringBuffer append(String str) {`
3.  `toStringCache = null;`
4.  `super.append(str);`
5.  `return this;`
6.  `}`

从源码中可以看出，append方法用了synchronized关键词，它是线程安全的。但我们可能仅在线程内部把StringBuffer当作局部变量使用：

1.  `package com.leeib.thread;`
2.  ``  
    
3.  `public class Demo {`
4.  ``  
    
5.  `public static void main(String[] args) {`
6.  `long start = System.currentTimeMillis();`
7.  `int size = 10000;`
8.  `for (int i = 0; i < size; i++) {`
9.  `createStringBuffer("Hyes", "为分享技术而生");`
10. `}`
11. `long timeCost = System.currentTimeMillis() - start;`
12. `System.out.println("createStringBuffer:" + timeCost + " ms");`
13. ``  
    
14. `}`
15. ``  
    
16. `public static String createStringBuffer(String str1, String str2) {`
17. `StringBuffer sBuf = new StringBuffer();`
18. `sBuf.append(str1);// append方法是同步操作`
19. `sBuf.append(str2);`
20. `return sBuf.toString();`
21. `}`
22. ``  
    
23. `}`

代码中createStringBuffer方法中的局部对象sBuf，就只在该方法内的作用域有效，不同线程同时调用createStringBuffer()方法时，都会创建不同的sBuf对象，因此此时的append操作若是使用同步操作，就是白白浪费的系统资源。

这时我们可以通过编译器将其优化，将锁消除，前提是java必须运行在server模式（server模式会比client模式作更多的优化），同时必须开启逃逸分析:

1.  `-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks`

其中+DoEscapeAnalysis表示开启逃逸分析，+EliminateLocks表示锁消除。

> 逃逸分析：比如上面的代码，它要看sBuf是否可能逃出它的作用域？如果将sBuf作为方法的返回值进行返回，那么它在方法外部可能被当作一个全局对象使用，就有可能发生线程安全问题，这时就可以说sBuf这个对象发生逃逸了，因而不应将append操作的锁消除，但我们上面的代码没有发生锁逃逸，锁消除就可以带来一定的性能提升。

以上就是java锁优化的5个方法或思想。

转载：[http://www.hao124.net/article/70][http_www.hao124.net_article_70]

[Link 1]: http://www.hao124.net/article/28
[Link 2]: http://www.hao124.net/article/24
[07cf641bd8d62a6f18140f24236028bd.PNG]: http://img.hao124.net/07cf641bd8d62a6f18140f24236028bd.PNG
[http_www.hao124.net_article_70]: http://www.hao124.net/article/70