降低锁的竞争可以提高并发程序的性能和可伸缩性,有3种方式可以降低锁的竞争:
1. 减少锁的持有时间(缩小锁的范围)
2. 降低锁的请求频率(降低锁的粒度)
3. 放弃使用独占锁,使用并发容器,原子变量,读写锁等等来代替它。
减少锁的持有时间(减小锁的范围):
减少锁的持有时间实际上就是减小锁的控制范围,将一些并不需要锁的操作从同步代码块中移除。如下所示,需要进行同步操作的只有attributes.get(key);这一行代码。
缩小锁的范围如下,将不需要同步的内容移出代码块。
降低锁的请求频率(降低锁的粒度):
通过将粗粒度的锁分解为多个细粒度的锁,从而将原来到一个锁的请求分担到多个锁。常用的方案是锁分解或锁分段(一个锁分解为两个锁称为锁分解,一个锁分解为多个锁称为锁分段)。 在代码中,当一个锁需要同时保护多个互相独立的共享状态变量的时候,可以考虑锁分解或锁分段。
先来看一个 锁分解的例子:
在上面的代码中,同一个ServerStatus对象锁用于保护2个独立的共享变量,可以使用锁分解。
锁分段的典型应用是ConcurrentHashMap。在Collections.synchronizedMap()方法中,使用组合的方式将传入Map的方法放入同步代码块中执行,所有的同步代码块使用同一个对象锁。为了提高容器的性能,在ConcurrentHashMap容器中使用16个对象锁,每个对象锁保护所有散列桶的1/16,其中第N个散列桶由第(N%16)个对象锁来保护。大致的思路如下:
放弃使用独占锁:
1. 减少锁的持有时间(缩小锁的范围)
2. 降低锁的请求频率(降低锁的粒度)
3. 放弃使用独占锁,使用并发容器,原子变量,读写锁等等来代替它。
减少锁的持有时间(减小锁的范围):
减少锁的持有时间实际上就是减小锁的控制范围,将一些并不需要锁的操作从同步代码块中移除。如下所示,需要进行同步操作的只有attributes.get(key);这一行代码。
//可以优化的代码
class AttributeStore{
private final Map<String,String> attributes=new HashMap<String,String>();
public synchronized boolean userLocationMatches(String username,String regex){
String key="user."+username;
String location=attributes.get(key);
if(location==null)
return false;
else
return Pattern.matches(regex,location);
}
}
缩小锁的范围如下,将不需要同步的内容移出代码块。
//优化之后的代码
class AttributeStore{
private final Map<String,String> attributes=new HashMap<String,String>();
public boolean userLocationMatches(String username,String regex){
String key="user."+username;
String location;
synchronized (this) {
location=attributes.get(key);
}
if(location==null)
return false;
else
return Pattern.matches(regex,location);
}
}
降低锁的请求频率(降低锁的粒度):
通过将粗粒度的锁分解为多个细粒度的锁,从而将原来到一个锁的请求分担到多个锁。常用的方案是锁分解或锁分段(一个锁分解为两个锁称为锁分解,一个锁分解为多个锁称为锁分段)。 在代码中,当一个锁需要同时保护多个互相独立的共享状态变量的时候,可以考虑锁分解或锁分段。
先来看一个 锁分解的例子:
//可以锁分解的代码
class ServerStatus{
private Set<String> users;
private Set<String> queries;
public synchronized void addUser(String user){
users.add(user);
}
public synchronized void removeUser(String user){
users.remove(user);
}
public synchronized void addQuery(String query){
queries.add(query);
}
public synchronized void removeQuery(String query){
queries.remove(query);
}
}
在上面的代码中,同一个ServerStatus对象锁用于保护2个独立的共享变量,可以使用锁分解。
//优化后的代码
class ServerStatus{
private Set<String> users;
private Set<String> queries;
public void addUser(String user){
synchronized (users) {
users.add(user);
}
}
public void removeUser(String user){
synchronized (users) {
users.remove(user);
}
}
public void addQuery(String query){
synchronized (queries) {
queries.add(query);
}
}
public void removeQuery(String query){
synchronized (queries) {
queries.remove(query);
}
}
}
锁分段的典型应用是ConcurrentHashMap。在Collections.synchronizedMap()方法中,使用组合的方式将传入Map的方法放入同步代码块中执行,所有的同步代码块使用同一个对象锁。为了提高容器的性能,在ConcurrentHashMap容器中使用16个对象锁,每个对象锁保护所有散列桶的1/16,其中第N个散列桶由第(N%16)个对象锁来保护。大致的思路如下:
class MyMap<K,V>{
static final class Node<K,V>{
private K key;
private V value;
private Node<K,V> next;
public Node<K, V> getNext() {
return next;
}
//...set get equals hashCode...//
}
private final static int N_LOCKS=16;
private Object[] mylocks;
private Node<K,V>[] buckets;
public MyMap(int num) {
mylocks=new Object[N_LOCKS];
for(int i=0;i<N_LOCKS;i++){
mylocks[i]=new Object();
}
buckets=new Node[num];
}
public V get(K key){
int bucketIndex=key.hashCode()%buckets.length;//定位目标所在的桶
synchronized (mylocks[bucketIndex%N_LOCKS]) {//获取桶对应的锁
for(Node<K,V> node=buckets[bucketIndex];node!=null;node=node.getNext()){
if(key.equals(node.key))
return node.value;
}
return null;
}
}
//......
}
放弃使用独占锁:
我们可以放弃使用独占锁,使用并发容器,原子变量,读写锁等等来代替他。
笔者开设了一个知乎live,详细的介绍的JAVA从入门到精通该如何学,学什么?
提供给想深入学习和提高JAVA能力的同学,欢迎收听https://www.zhihu.com/lives/932192204248682496