降低锁的竞争可以提高并发程序的性能和可伸缩性，有3种方式可以降低锁的竞争：
 
1. 减少锁的持有时间（缩小锁的范围） 
2. 降低锁的请求频率（降低锁的粒度） 
3. 放弃使用独占锁，使用并发容器，原子变量，读写锁等等来代替它。 

减少锁的持有时间（减小锁的范围）：
 

减少锁的持有时间实际上就是减小锁的控制范围，将一些并不需要锁的操作从同步代码块中移除。如下所示，需要进行同步操作的只有attributes.get(key);这一行代码下载 。 

Java代码  

1. //可以优化的代码  
2. class AttributeStore{  
3.     private final Map<String,String> attributes=new HashMap<String,String>();  
4.     public synchronized boolean userLocationMatches(String username,String regex){  
5.         String key=“user.”+username;  
6.         String location=attributes.get(key);  
7.         if(location==null)  
8.             return false;  
9.         else  
10.             return Pattern.matches(regex,location);  
11.     }  
12. }  

缩小锁的范围如下，将不需要同步的内容移出代码块。 

Java代码  

1. //优化之后的代码  
2. class AttributeStore{  
3.     private final Map<String,String> attributes=new HashMap<String,String>();  
4.     public boolean userLocationMatches(String username,String regex){  
5.         String key=“user.”+username;  
6.         String location;  
7.         synchronized (this) {  
8.             location=attributes.get(key);             
9.         }  
10.         if(location==null)  
11.             return false;  
12.         else  
13.             return Pattern.matches(regex,location);  
14.     }  
15. }  

降低锁的请求频率（降低锁的粒度）：
 

通过将粗粒度的锁分解为多个细粒度的锁，从而将原来到一个锁的请求分担到多个锁。常用的方案是锁分解或锁分段（一个锁分解为两个锁称为锁分解，一个锁分解为多个锁称为锁分段下载 ）。
在代码中，当一个锁需要同时保护多个互相独立的共享状态变量的时候，可以考虑锁分解或锁分段。
 

先来看一个
锁分解
的例子： 

Java代码  

1. //可以锁分解的代码  
2. class ServerStatus{  
3.     private  Set<String> users;  
4.     private  Set<String> queries;  
5.     public synchronized void addUser(String user){  
6.         users.add(user);  
7.     }  
8.     public synchronized void removeUser(String user){  
9.         users.remove(user);  
10.     }  
11.       
12.     public synchronized void addQuery(String query){  
13.         queries.add(query);  
14.     }  
15.     public synchronized void removeQuery(String query){  
16.         queries.remove(query);  
17.     }     
18. }  

在上面的代码中，同一个ServerStatus对象锁用于保护2个独立的共享变量，可以使用锁分解下载   。 

Java代码  

1. //优化后的代码  
2. class ServerStatus{  
3.     private  Set<String> users;  
4.     private  Set<String> queries;  
5.     public  void addUser(String user){  
6.         synchronized (users) {  
7.             users.add(user);  
8.         }  
9.     }  
10.     public  void removeUser(String user){  
11.         synchronized (users) {  
12.             users.remove(user);  
13.         }  
14.     }  
15.       
16.     public  void addQuery(String query){  
17.         synchronized (queries) {  
18.             queries.add(query);  
19.         }  
20.     }  
21.     public  void removeQuery(String query){  
22.         synchronized (queries) {  
23.             queries.remove(query);  
24.         }  
25.     }     
26. }  

锁分段
的典型应用是ConcurrentHashMap。在Collections.synchronizedMap()方法中，使用组合的方式将传入Map的方法放入同步代码块中执行，所有的同步代码块使用同一个对象锁。为了提高容器的性能，在ConcurrentHashMap容器中使用16个对象锁，每个对象锁保护所有散列桶的1/16，其中第N个散列桶由第（N%16）个对象锁来保护。大致的思路如下： 

Java代码  

1. class MyMap<K,V>{  
2.     static final class Node<K,V>{  
3.         private K key;  
4.         private V value;  
5.         private Node<K,V> next;  
6.         public Node<K, V> getNext() {  
7.             return next;  
8.         }  
9.         //…set get equals hashCode…//  
10.     }  
11.     private final static int N_LOCKS=16;  
12.     private Object[] mylocks;  
13.     private Node<K,V>[] buckets;  
14.     public MyMap(int num) {  
15.         mylocks=new Object[N_LOCKS];  
16.         for(int i=0;i<N_LOCKS;i++){  
17.             mylocks[i]=new Object();  
18.         }  
19.         buckets=new Node[num];  
20.     }  
21.       
22.     public V get(K key){  
23.         int bucketIndex=key.hashCode()%buckets.length;//定位目标所在的桶  
24.         synchronized (mylocks[bucketIndex%N_LOCKS]) {//获取桶对应的锁  
25.             for(Node<K,V> node=buckets[bucketIndex];node!=null;node=node.getNext()){  
26.                 if(key.equals(node.key))  
27.                     return node.value;  
28.             }  
29.             return null;  
30.         }  
31.     }  
32.     //……  
33. }