代码之家 › 专栏 › 技术社区 › Rachel

使用并发的Java性能

concurrency collections performance java

Rachel · 技术社区 · 14 年前

如何提高的性能这段代码?

代码:

    public class SlowDictionary {
        private final Map<String,String> dict = new HashMap<String,String>();
        public synchronized String translate (String word)
        throws IllegalArgumentException {
            if (!dict.containsKey(word)) {
                throw new IllegalArgumentException(word + " not found.");
            }
            return dict.get(word);
        }

        public synchronized void addToDictionary (String word, String translation) 
            throws IllegalArgumentException {
            if (dict.containsKey(word)) {
                throw new IllegalArgumentException(word + " already exists.");
            }
            dict.put(word,translation);
        }

        public synchronized Set<String> getAllWords () {    
            return dict.keySet();
        }
    }

8 回复 | 直到 14 年前

John Vint 14 年前

首先要做的是去掉所有同步的关键字。

最简单的方法是将dict声明为ConcurrentHashMap:

private final ConcurrentMap<String,String> dict = new ConcurrentHashMap<String,String>();

 public String translate (String word) throws IllegalArgumentException { ..

原因是CCHM持有的最新合同。

最后,add to dictionary可以如下所示:

 public void addToDictionary (String word, String translation) throws IllegalArgumentException {
            if (dict.putIfAbsent(word,translation)!=null) {
                throw new IllegalArgumentException(word + " already exists.");
            }
        }

也可以从getAllWords中删除synchronized。

编辑:在考虑了汤姆的评论之后。在这个“例外情况”中进行双重查找可能不值得。如果案例没有抛出异常,那么它将是合适的。

BlairHippo 14 年前

把所有的 synchronized dict ConcurrentHashMap 也许值得一试。

Tom Hawtin - tackline 14 年前

构造和抛出异常很慢,所以不要这样做。
确保在每个方法中只使用一个map操作,而不是将查找加倍。
ConcurrentHashMap 而不是 synchronized

getAllWords 方法不是线程安全的,或者至少 Set 它不会回来。

Jed Wesley-Smith 14 年前

当你说提高性能时,你对使用率统计有什么想法吗?例如,有多少写入到读取,以及内部映射有多大?

如果读取的数量成比例地高,并且映射主要在启动时填充(并且不是很大),那么一个copy-on-write策略可能是最好的选择。我们使用(并保持)了 CopyOnWriteMap 对于并发读取,它的性能比ConcurrentHashMap好(在我们的测试中提高了大约10%)。

Peter Lawrey 14 年前

在下面的示例中,每个方法访问一次映射,而不是两次(无同步)

public class SlowDictionary { 
    private final ConcurrentMap<String,String> dict = new ConcurentHashMap<String,String>(); 

    public String translate (String word) throws IllegalArgumentException { 
        String translation = dict.get(word);
        if (translation == null) 
            throw new IllegalArgumentException(word + " not found."); 
        return translation; 
    } 

    public void addToDictionary (String word, String translation) throws IllegalArgumentException { 
        if (dict.putIfAbsent(word, translation) != null) 
            throw new IllegalArgumentException(word + " already exists."); 
    } 

    public Set<String> getAllWords () {     
        return dict.keySet(); 
    } 
}

corsiKa 14 年前

LiorH 14 年前

如果读的比写的多(通常是这样),可以考虑使用 ReadWriteLock 这样读者就不会互相阻拦了。

NoozNooz42 14 年前

有一个许多一种储存词典的有效方法。使用重量级的东西,比如Java的默认HashMap和String对象,并不是其中之一。

因此,当然,您可以去掉synchronized关键字,并尝试通过处理Java特殊短语来获得一点点左右的速度。

当然,有地图包含是O(1)。。。但是当你在地图中放入数百万个字符串时,它的大小并不是O(1);)

深思熟虑:用Trie来判断一个词是否存在,可能比简单地用Trie来判断要快计算 “让我们用一个HashMap,它是O(1),所以你不能打败它”

我可以告诉你,比如说,Google的“translate”和Google的“find as you type”绝对不是通过在内存中存储数百万个Java字符串对象来实现的 我-需要-不断调整大小-和-我-调整大小-非常缓慢

你的要求是什么?多少字?支持多少种语言?