Recherchez plusieurs hachages en même temps

Je pense que le plus facile serait d'utiliser un flux sur le jeu d'entrée:

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.
}

Peut-être essayez peut-être des piscines de thread:

ExecutorService es = Executors.newFixedThreadPool(_numDictionaries);
for (int i = 0; i < _numDictionaries; i++) {
    //prepare a Runnable implementation that contains a logic of your search
    es.submit(prepared_runnable);
}

J'ai mes forts doutes que les hashmaps sont une solution appropriée ici, surtout si vous voulez avoir des mots de floue et d'arrêt. Vous devez utiliser une solution de recherche de texte complète appropriée comme elaticsearch ou Apache Solr ou au moins un moteur disponible comme Apache Lucene .

Cela étant dit, vous pouvez utiliser la version d'un homme pauvre: créer une matrice de vos cartes et une sorte de type, itérale sur la matrice, prenez les clés du hashmap actuel et de les stocker dans le type de type avec l'index de leur hashmap. Pour récupérer une clé, vous recherchez d'abord dans la sélection de cartes pour ladite clé, obtenez le hashmap respectif de la matrice à l'aide de la position de l'index et recherchez la clé dans un seul hashmap. Devrait être suffisamment rapide sans avoir besoin de multiples threads de creuser par les hachons. Cependant, vous pouvez rendre le code ci-dessous dans un fichier runnable et vous pouvez avoir plusieurs recherches en parallèle. xxx

Veuillez noter qu'il s'agit d'une mise en œuvre plutôt naïve que prévue à des fins d'illustration. Il ne traite pas de plusieurs problèmes (vous ne pouvez pas avoir des entrées d'index en double, par exemple).

Avec cette solution, vous négociez essentiellement une vitesse de démarrage pour la vitesse de requête.

D'accord! Peut conserver trois dictionnaires d'un fil et de repos deux prendront soin par un autre fil. Et puis la sorcière jamais thread trouve le match arrêtera ou terminera l'autre thread.

Peut-être que vous avez besoin d'une logique supplémentaire pour faire ce travail de division ... mais cela n'exploitera pas votre temps de performance.

et peut-être que vous avez besoin de plus de changements supplémentaires dans votre code pour obtenir votre correspondance fermée: xxx

Vous utilisez entrée mais vous n'êtes pas En utilisant les valeurs de toute façon, il semble que le jeu d'entrée est un peu cher. Et je vous suggère de simplement utiliser Keyset car vous n'êtes pas vraiment intéressé par les valeurs dans cette carte xxx

Pour plus de détails sur le proformance de la carte, veuillez lire ce lien Performances de carte < / a>

L'itération sur la collection-Vues d'un LinkedHashMap nécessite du temps proportionnel à la taille de la carte, quelle que soit sa capacité. L'itération sur un hachemme est susceptible d'être plus chère, nécessitant du temps proportionnel à sa capacité.