Question

tldr ：如何同时在多个（只读）Java HashMaps中搜索条目？

长版：

我有几个不同大小的词典存储为HashMap< String, String >。一旦他们被读入，他们永远不会被改变（严格只读）。我想检查是否以及哪个字典用我的密钥存储了一个条目。

我的代码最初正在寻找这样的密钥：

public DictionaryEntry getEntry(String key) {
    for (int i = 0; i < _numDictionaries; i++) {
        HashMap<String, String> map = getDictionary(i);
        if (map.containsKey(key))
             return new DictionaryEntry(map.get(key), i);
    }
    return null;
}

然后它变得有点复杂：我的搜索字符串可能包含拼写错误，或者是存储条目的变体。就像，如果存储的密钥是＆＃34; banana＆＃34;，我可能会查找＆＃34; bannana＆＃34;或者＆＃34;香蕉＆＃34;，但仍然想要＆＃34; banana＆＃34;回。使用Levenshtein-Distance，我现在遍历所有词典及其中的每个条目：

public DictionaryEntry getEntry(String key) {
    for (int i = 0; i < _numDictionaries; i++) {
        HashMap<String, String> map = getDictionary(i);
        for (Map.Entry entry : map.entrySet) {
            // Calculate Levenshtein distance, store closest match etc.
        }
    }
    // return closest match or null.
}

到目前为止一切正常，我得到了我想要的条目。不幸的是，我需要查找大约7000个字符串，在五个不同大小的字典中（约30-70k条目），这需要一段时间。从我的处理输出中，我的强烈印象是我的查找主导整个运行时。

我改善运行时的第一个想法是并行搜索所有词典。由于没有一个字典需要更改，并且不会有多个线程同时访问字典，因此我没有看到任何安全问题。

问题是：我该怎么做？我之前从未使用过多线程。我的搜索只提出了Concurrent HashMaps（但根据我的理解，我不需要这个）和Runnable类，我必须将我的处理放入方法run()。我想我可以重写我当前的类以适应Runnable，但我想知道是否有更简单的方法可以做到这一点（或者我怎么能用Runnable做到这一点，现在我的有限理解认为我必须重组很多）。

因为我被要求分享Levenshtein-Logic：它真的没什么特别的，但是你走了：

private int _maxLSDistance = 10;
public Map.Entry getClosestMatch(String key) {
    Map.Entry _closestMatch = null;
    int lsDist;

    if (key == null) {
        return null;
    }

    for (Map.Entry entry : _dictionary.entrySet()) {
        // Perfect match
        if (entry.getKey().equals(key)) {
            return entry;
        }
        // Similar match
        else {
            int dist = StringUtils.getLevenshteinDistance((String) entry.getKey(), key);

            // If "dist" is smaller than threshold and smaller than distance of already stored entry
            if (dist < _maxLSDistance) {
                if (_closestMatch == null || dist < _lsDistance) {
                    _closestMatch = entry;
                    _lsDistance = dist;
                }
            }
        }
    }
    return _closestMatch
}

Answer 1

为了在你的情况下使用多线程，可能是这样的：

＆＃34;监视器＆＃34; class，它基本上存储结果并协调线程;

sort

Thread it's self，可以设置为搜索特定字典：

public class Results {

    private int nrOfDictionaries = 4; //

    private ArrayList<String> results = new ArrayList<String>();

    public void prepare() {
        nrOfDictionaries = 4;
        results = new ArrayList<String>();
    }

    public synchronized void oneDictionaryFinished() {
        nrOfDictionaries--;
        System.out.println("one dictionary finished");
        notifyAll();
    }

    public synchronized boolean isReady() throws InterruptedException {

        while (nrOfDictionaries != 0) {
            wait();
        }

        return true;
    }

    public synchronized void addResult(String result) {
        results.add(result);
    }

    public ArrayList<String> getAllResults() {
        return results;
    }
}

演示的主要方法：

public class ThreadDictionarySearch extends Thread {

    // the actual dictionary
    private String dictionary;
    private Results results;

    public ThreadDictionarySearch(Results results, String dictionary) {
        this.dictionary = dictionary;
        this.results = results;
    }

    @Override
    public void run() {

        for (int i = 0; i < 4; i++) {
            // search dictionary;
            results.addResult("result of " + dictionary);
            System.out.println("adding result from " + dictionary);
        }

        results.oneDictionaryFinished();
    }

}

Answer 2

我认为最简单的方法是在条目集上使用流：

public DictionaryEntry getEntry(String key) {
  for (int i = 0; i < _numDictionaries; i++) {
    HashMap<String, String> map = getDictionary(i);

    map.entrySet().parallelStream().foreach( (entry) ->
                                     {
                                       // Calculate Levenshtein distance, store closest match etc.
                                     }
      );
  }
  // return closest match or null.
}

如果你当然使用java 8。您也可以将外部循环包装到IntStream中。您也可以直接使用Stream.reduce获取距离最小的条目。

Answer 3

也许尝试线程池：

<input type="fecha" class="form-control" id="fecha" ng-model="cf.fecha" value="{{formCtrl.formulario.fecha | date}}"  disabled>

我相信您也可以尝试快速估算完全不匹配的字符串（即长度上的显着差异），并使用它尽快完成逻辑，转移到下一个候选者。

Answer 4

我非常怀疑HashMaps在这里是一个合适的解决方案，特别是如果你想要一些模糊和停止的话。您应该使用适当的全文搜索解决方案，例如ElaticSearch或Apache Solr，或者至少使用Apache Lucene之类的可用引擎。

话虽这么说，你可以使用一个穷人的版本：创建你的地图数组和一个SortedMap，迭代数组，获取当前HashMap的键并将它们存储在SortedMap中，并使用其HashMap的索引。要检索密钥，首先在SortedMap中搜索所述密钥，使用索引位置从数组中获取相应的HashMap，并仅在一个HashMap中查找密钥。应该足够快，而不需要多线程来挖掘HashMaps。但是，您可以将下面的代码变为可运行的，并且可以并行进行多次查找。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

public class Search {

    public static void main(String[] arg) {

        if (arg.length == 0) {
            System.out.println("Must give a search word!");
            System.exit(1);
        }

        String searchString = arg[0].toLowerCase();

        /*
         * Populating our HashMaps.
         */
        HashMap<String, String> english = new HashMap<String, String>();
        english.put("banana", "fruit");
        english.put("tomato", "vegetable");

        HashMap<String, String> german = new HashMap<String, String>();
        german.put("Banane", "Frucht");
        german.put("Tomate", "Gemüse");

        /*
         * Now we create our ArrayList of HashMaps for fast retrieval
         */

        List<HashMap<String, String>> maps = new ArrayList<HashMap<String, String>>();
        maps.add(english);
        maps.add(german);


        /*
         * This is our index
         */
        SortedMap<String, Integer> index = new TreeMap<String, Integer>(String.CASE_INSENSITIVE_ORDER);


        /*
         * Populating the index:
         */
        for (int i = 0; i < maps.size(); i++) {
            // We iterate through or HashMaps...
            HashMap<String, String> currentMap = maps.get(i);

            for (String key : currentMap.keySet()) {
                /* ...and populate our index with lowercase versions of the keys,
                 * referencing the array from which the key originates.
                 */ 
                index.put(key.toLowerCase(), i);
            }

        }


         // In case our index contains our search string...
        if (index.containsKey(searchString)) {

            /* 
             * ... we find out in which map of the ones stored in maps
             * the word in the index originated from.
             */
            Integer mapIndex = index.get(searchString);

            /*
             * Next, we look up said map.
             */
            HashMap<String, String> origin = maps.get(mapIndex);

            /*
             * Last, we retrieve the value from the origin map
             */

            String result = origin.get(searchString);

            /*
             * The above steps can be shortened to
             *  String result = maps.get(index.get(searchString).intValue()).get(searchString);
             */

            System.out.println(result);
        } else {
            System.out.println("\"" + searchString + "\" is not in the index!");
        }
    }

}

请注意，这是一个相当天真的实现，仅用于说明目的。它没有解决几个问题（例如，您不能有重复的索引条目）。

使用此解决方案，您基本上可以为查询速度交换启动速度。

Answer 5

好的!! ..

由于您的关注是要加快响应速度。

我建议你在线程之间划分工作。

让你有5个字典可以将三个字典保存到一个线程，其余两个将由另一个线程处理。然后，女巫线程发现匹配将停止或终止其他线程。

可能你需要一个额外的逻辑去做分工...但这不会影响你的表演时间。

您可能需要对代码进行更改才能获得近距离匹配：

for (Map.Entry entry : _dictionary.entrySet()) {

你正在使用EntrySet但是你并没有使用价值观，因为看起来条目设置有点贵。我建议您只使用keySet，因为您对该地图中的values并不感兴趣

 for (Map.Entry entry : _dictionary.keySet()) {

有关地图性能的详细信息请阅读此链接Map performances

迭代LinkedHashMap的集合视图需要与地图大小成比例的时间，无论其容量如何。对HashMap的迭代可能更昂贵，需要与其容量成比例的时间。

同时搜索多个HashMaps

5 个答案: