使用并发的 Java 性能

Question

1. 如何提高性能 这段代码？
2. 给定问题陈述的单元测试用例是什么？

代码：

    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();
        }
    }

Answer 1

你要做的第一件事就是去掉所有同步的关键词。

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

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

这样做您可以立即删除 translate 的同步部分，使其看起来像：

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

原因是 CCHM 持有的关于最新读取的合同。

最后，添加到字典可以是这样的：

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

同时从 getAllWords 中删除同步。

编辑：在考虑了汤姆的评论之后。在这种“例外情况”中进行双重查找可能是不值得的。如果case没有抛出异常，那就合适了。

Answer 2

转储所有synchronized 关键字并将dict 定义为ConcurrentHashMap 可能值得一试。

Answer 3

1. 构造和抛出异常很慢，所以不要这样做。
2. 确保在每个方法中只使用一个映射操作，而不是加倍查找。
3. 如果同时大量使用，请使用ConcurrentHashMap 而不是synchronized。

注意，getAllWords 方法不是线程安全的，或者至少，它返回的 Set 不是。

Answer 4

当您说提高性能时，您对使用情况统计有任何想法吗？例如，多少次写入读取，内部映射有多大？

如果读取次数成比例地很高，并且映射主要在启动时填充（并且不是很大），那么写入时复制策略可能是您的最佳选择。我们使用（并维护）了一个CopyOnWriteMap，它的并发读取性能比 ConcurrentHashMap 更好（在我们的测试中提高了大约 10%）。

Answer 5

您应该使用 ConcurrentHashMap 但是在您当前的实现中，getAllWords() 仅在同步块内对数据具有线程安全副本毫无价值，即除非调用者也同步 collction，否则它不是线程安全的。解决此问题的一种方法是在返回之前获取副本（或使用 ConcurrentHashMap）

在以下示例中，每个方法访问一次映射，而不是两次。 （不同步）

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(); 
    } 
}

Answer 6

我可能会离开这里，但这看起来和你能得到的一样好。这基本上就是千篇一律的同步映射访问器。

Answer 7

如果您的读取次数多于写入次数（通常是这种情况），请考虑使用ReadWriteLock 这样读者就不会互相阻挡。

Answer 8

有很多有效的方法来存储字典。使用重量级的东西，比如 Java 的默认 HashMap 和 String 对象不是其中之一。

因此，当然，您可以摆脱 synchronized 关键字，并尝试通过解决 Java 特质来左右提高一点速度。

当然，地图的 contains 是 O(1)...但是当您将数百万个字符串放入其中时调整地图的大小不是 O(1) ;)

深思熟虑：使用 Trie 来确定单词是否存在可能比简单地计算字符串的哈希码更快（我并不是说你需要的是 trie ：我想说的是：不仅仅是“让我们使用 HashMap，它是 O(1)，所以你无法击败它”-meets-the-eye。

而且我可以告诉你，Google 的“翻译”和 Google 的“查找时键入”绝对不是通过在 I-need-constant-resizing- 中存储数百万个 Java 字符串对象来实现的和-I-resize-very-slowly Java HashMaps。

您有什么要求？多少字？支持多少种语言？