Salut! En tant que fournisseur de Combiner, j'ai reçu beaucoup de questions ces derniers temps sur ce qu'il faut pour qu'un Combiner soit thread-safe dans un travail MapReduce. J’ai donc pensé vous l’expliquer dans cet article de blog.
Tout d’abord, récapitulons rapidement ce qu’est un Combiner dans le contexte d’un travail MapReduce. Un combineur est une fonction facultative qui peut être utilisée pour effectuer une agrégation locale sur la sortie des mappeurs avant qu'elle ne soit envoyée aux réducteurs. Cela peut réduire considérablement la quantité de données transférées sur le réseau, ce qui accélère l'exécution globale des tâches.
Maintenant, la grande question est la suivante : quelles sont les exigences pour qu'un combinateur soit thread-safe ?
Immuabilité de l'entrée et de la sortie
L'une des exigences fondamentales d'un combineur thread-safe est l'immuabilité de son entrée et de sa sortie. Lorsque plusieurs threads accèdent simultanément au Combiner, nous ne voulons pas qu'aucun d'entre eux modifie les données d'une manière qui pourrait affecter les autres threads.
Par exemple, si les données d'entrée du Combiner sont mutables, un thread peut modifier les valeurs tandis qu'un autre essaie de les lire ou de les traiter. Cela peut conduire à des résultats incohérents. De même, la sortie du Combiner doit également être immuable. Si d'autres parties du framework MapReduce commencent à modifier la sortie du Combiner alors qu'il est encore utilisé par d'autres threads, cela peut provoquer toutes sortes de problèmes.
Disons que nous travaillons sur un mot - comptez le travail MapReduce. Le mappeur génère des paires clé-valeur où la clé est un mot et la valeur est le nombre. Le Combiner regroupe ces décomptes pour chaque mot. Si les paires clé-valeur sont mutables, un thread peut modifier la valeur du nombre pendant qu'un autre thread tente de calculer le nombre total pour ce mot. Cela entraînerait un décompte final incorrect.
Opérations atomiques
Les opérations atomiques sont un autre aspect crucial des combineurs thread-safe. Une opération atomique est une opération qui apparaît au reste du système comme si elle était effectuée instantanément. Dans le contexte d'un combineur, les opérations atomiques garantissent que plusieurs threads peuvent effectuer des opérations sur des données partagées sans interférer les uns avec les autres.
Par exemple, lors de l'agrégation de valeurs dans le Combiner, nous devons utiliser des opérations d'incrémentation ou d'addition atomique. En Java, leEntier atomiquela classe fournit des opérations atomiques pour les entiers. Au lieu d'utiliser une variable entière régulière pour suivre le décompte, nous pouvons utiliser unEntier atomique. De cette façon, lorsque plusieurs threads tentent d'incrémenter le nombre simultanément, l'opération est garantie d'être atomique et nous n'obtiendrons pas de résultats incohérents.
Prenons à nouveau le mot - comptez l'exemple. Au lieu d'utiliser un entier régulier pour suivre le décompte de chaque mot, nous pouvons utiliser unEntier atomique. Lorsqu'un fil de discussion souhaite augmenter le nombre d'un mot particulier, il peut appeler leincrémentAndGet()méthode duEntier atomique. Cette méthode est atomique, donc même si plusieurs threads tentent d'incrémenter le décompte en même temps, l'opération sera effectuée correctement.
Mécanismes de synchronisation
Parfois, les opérations atomiques peuvent ne pas suffire et nous devons utiliser des mécanismes de synchronisation pour garantir la sécurité des threads. La synchronisation nous permet de contrôler l'accès aux ressources partagées afin qu'un seul thread puisse y accéder à la fois.
En Java, nous pouvons utiliser lesynchronisémot-clé pour créer des méthodes ou des blocs synchronisés. Par exemple, si notre Combiner a une structure de données partagée comme unCarte de hachagepour stocker les valeurs agrégées, nous pouvons utiliser un bloc synchronisé pour garantir qu'un seul thread peut accéder auCarte de hachageà la fois.
importer java.util.HashMap ; public class MyCombiner { private HashMap<String, Integer> countMap = new HashMap<>(); public void combine(String key, int value) { synchronisé (this) { if (countMap.containsKey(key)) { countMap.put(key, countMap.get(key) + value); } else { countMap.put(clé, valeur); } } } }Dans cet exemple, lecombinerLa méthode est synchronisée, ce qui signifie qu'un seul thread peut exécuter cette méthode à la fois. Cela garantit que leCarte de hachageest accessible et modifié de manière thread-safe.
Éviter l’état global
L'état global peut être un cauchemar lorsqu'il s'agit de programmation thread-safe. Si un combineur s'appuie sur des variables globales ou des ressources partagées qui peuvent être modifiées par plusieurs threads, il est très probable qu'il se heurte à des conditions de concurrence critique et à d'autres problèmes de sécurité des threads.
Au lieu de cela, nous devrions essayer de garder l’état du Combiner aussi local que possible. Chaque thread doit avoir sa propre copie des données sur lesquelles il doit opérer, et les résultats doivent être combinés de manière thread-safe à la fin.
Par exemple, au lieu d'utiliser un globalCarte de hachagepour stocker les valeurs agrégées, nous pouvons utiliser un localCarte de hachagepour chaque fil. Une fois toutes les agrégations locales réalisées, nous pouvons fusionner cesCartes de hachagedans un fil - de manière sûre.
Tests de sécurité des threads
Les tests sont un élément essentiel pour garantir qu'un combineur est thread-safe. Nous devons tester le Combiner dans différents scénarios avec plusieurs threads pour nous assurer qu'il produit des résultats cohérents.
Une façon de tester la sécurité des threads consiste à utiliser un cadre de test multithread. Par exemple, JUnit peut être utilisé pour écrire des cas de test multithreads. Nous pouvons créer plusieurs threads qui appellent le Combiner simultanément, puis vérifier que la sortie est correcte.
Nous pouvons également utiliser des outils tels que FindBugs ou les outils d'analyse statique intégrés d'IntelliJ IDEA pour détecter les problèmes potentiels de sécurité des threads dans le code. Ces outils peuvent identifier des erreurs courantes telles que l'utilisation d'opérations non atomiques sur des variables partagées ou une mauvaise synchronisation de l'accès aux ressources partagées.
Nos produits combinateurs
En tant que fournisseur de combineurs, nous proposons une gamme de combineurs de haute qualité conçus dans un souci de sécurité des filetages. NotreCombineur de tête de réseau passif à 12 canauxetCombineur de tête de réseau passif 24 canauxsont parfaits pour les tâches MapReduce où la sécurité des threads est une préoccupation. Ces combineurs sont construits à l'aide des dernières technologies et sont rigoureusement testés pour garantir qu'ils répondent aux normes les plus élevées de performance et de fiabilité.
Si vous êtes à la recherche d'un combinateur thread-safe pour votre travail MapReduce, nous serions ravis de vous entendre. Que vous soyez un développeur à petite échelle ou une grande entreprise, nous avons la solution adaptée pour vous. N'hésitez pas à nous contacter et à entamer une conversation sur vos besoins spécifiques. Nous sommes là pour vous aider à trouver le meilleur Combiner pour vos besoins et garantir que vos tâches MapReduce se déroulent de manière fluide et efficace.
Références
- Tom Blanc. "Hadoop : le guide définitif." O'Reilly Media, 2015.
- Brian Goetz et coll. «La concurrence Java en pratique». Addison-Wesley Professionnel, 2006.
