Comprendre le traitement parallèle Java (Introduction)
Par exemple, avez-vous implémenté les points suivants en tenant compte du traitement parallèle?
- Singleton
- Incrémenter (
++) et décrémenter (-) - Substitution à "long" ou "double"
- Variables déclarées avec la balise
<%!%>
Si vous implémentez ce code sans aucune considération, ** cela peut provoquer des bogues ridicules dans votre système de production. ** **
Dans cet article, je voudrais expliquer le traitement parallèle selon le flux suivant.
- Qu'est-ce que le traitement parallèle?
- Pourquoi envisager un traitement parallèle?
- Variables thread-safe et non thread-safe
- Le traitement parallèle est difficile à tester
Qu'est-ce que le "traitement parallèle"?
Tout d'abord, comprenons comment Java fonctionne en mémoire.
"Process" et "Thread"
- ** Process **: Une unité de traitement qui fonctionne dans une zone appelée "espace mémoire" allouée en mémoire pour chaque application Java.
- ** Thread **: Traitez une série de programmes qui exécutent du code ligne par ligne sur le processus
- ** Multi-processus **: plusieurs processus peuvent s'exécuter en même temps
- ** Multi-thread **: plusieurs threads s'exécutant en même temps
Diverses données pour exécuter des programmes sont stockées dans l'espace mémoire. L'espace mémoire n'est pas partagé entre les processus, mais l'espace mémoire est partagé entre les threads. Autrement dit, ** différents threads peuvent accéder aux mêmes données. ** **
Types de traitement des threads
- ** Séquentiel **: Traitement de plusieurs threads en séquence en un seul processus
- ** Parallèle **: plusieurs processus traitant chaque thread en même temps
- ** Concurrent **: ** Traitement simultané de plusieurs threads en même temps en opérant tout en commutant plusieurs threads en un seul processus **
Parmi ceux-ci, le traitement parallèle et le traitement parallèle correspondent au «multi-thread» qui traite plusieurs threads en même temps. D'autre part, le traitement séquentiel est appelé "thread unique" car il traite les threads un par un.
Une chose à surveiller est le ** traitement parallèle **. Étant donné que plusieurs threads partagent de l'espace mémoire les uns avec les autres, si les threads sont exécutés en même temps, les données lues et écrites par un thread peuvent être lues et écrites par l'autre thread.
[Cours de programmation sécurisée IPA ISEC: C / C ++ Language Edition Chapitre 4 Contre-mesures pour les situations imprévues: contre-mesures générales pour les conditions de course](https://www.ipa.go.jp/security/awareness/vendor/programmingv2/contents /c304.html)
Pourquoi la concurrence doit être envisagée
Regardons la raison pour laquelle le traitement parallèle doit être considéré à travers un exemple.
Par exemple, supposons que vous disposez du système de réservation de location de bibliothèque suivant. À ce stade, le nombre de réservations pour le livre "Java Parallel Processing Programming" est supposé être de 0 à ce moment.
- Obtenez le nombre de réservations
- Ajoutez 1 au nombre de réservations obtenues
- Traitez le nombre de personnes réservées 2. Mettez à jour avec la valeur en 2.
Et si Alice et Bob réservaient "Java Concurrency Programming" en même temps? En fonction du moment choisi, le traitement peut être exécuté dans l'ordre suivant.
- A1. Alice obtient le nombre de réservations (= 0 personne)
- A2. Alice ajoute 1 au nombre de réservations obtenues (= 1 personne)
- B1. Bob obtient le nombre de réservations (= 0 personne)
- B2. Bob ajoute 1 au nombre de réservations obtenues (= 1 personne)
- A3. Alice traite le nombre de réservations et de mises à jour avec la valeur de 2. (= 1 personne)
- B3. Bob traite le nombre de réservations et de mises à jour avec la valeur de 2. (= 1 personne)
Alice et Bob, qui croient tous deux avoir réservé plus tôt que quiconque, ont visité la bibliothèque le lendemain et se sont disputés.
Comme dans l'exemple ci-dessus, un bogue qui se produit lorsque des données qui n'étaient pas censées être accédées en même temps sont en fait accédées en parallèle à partir de plusieurs threads ** "Condition de course" On l'appelle "**". La plage qui doit être exploitée dans un seul thread dans un programme est appelée ** "section critique" **.
D'un autre côté, un programme qui fonctionne normalement même s'il est appelé à partir de plusieurs threads en même temps est appelé ** "thread safe" **.
Variables thread-safe et non thread-safe
En Java, certaines variables sont thread-safe et d'autres non. Je voudrais expliquer comment ces variables fonctionnent en mémoire.
Type de variable
- ** Variable locale **: une variable qui est décrite dans la méthode et définit l'état de chaque méthode et constructeur.
- ** Variable d'instance **: Une variable qui peut être décrite en dehors de la méthode et référencée par d'autres méthodes et constructeurs. Peut être référencé à partir de n'importe quelle méthode de la même classe.
- ** Variable de classe **: une variable avec le modificateur statique ajouté à la variable d'instance. Les valeurs sont partagées entre plusieurs instances de la même classe.
public class ClassSample{
private String foo; //Variable d'instance
private static String bar; //Variable de classe
public static void methodSample(){
int num = 1; //Variables locales
}
}
Parmi ces variables, ** seules les variables locales sont ** thread-safe **.
Variables thread-safe
Les variables locales sont uniques à chaque thread et ne sont accessibles que par un seul thread car les données sont stockées dans une zone de l'espace mémoire appelée ** "zone de pile" **. Par conséquent, les autres threads ne réécrivent pas les informations ou se réfèrent par erreur aux informations.
Variables qui ne sont pas thread-safe
Les variables d'instance et les variables de classe sont partagées par plusieurs threads ** Puisque les données sont conservées dans une zone de l'espace mémoire appelée "zone de tas" **, d'autres threads peuvent réécrire les informations ou faire référence aux informations par erreur. Je peux le faire.
[Implémentation] N'oubliez pas de le rendre thread-safe | Nikkei xTECH (Cross Tech)
Faites également attention à la balise ** JSP <%!%> Utilisée lors de la déclaration de variables et de méthodes. La balise ** <%!%> N'est pas thread-safe car elle se développe en tant que variable d'instance Servlet ** ** lorsque la JSP est compilée.
Le traitement parallèle est difficile à tester
Les conditions de course sont des bogues de chronométrage très difficiles à détecter dans les tests **. ** **
Brian Goetz (Java Architect, Oracle, à partir de mars 2018), un des principaux experts du traitement parallèle Java, a écrit un article sur le traitement parallèle. Dans "Théorie et pratique Java: tuer sûrement les bogues" Est mentionné comme.
Sans surprise, l'écriture de code est le meilleur moment pour rendre votre code de haute qualité. C'est parce que j'ai la meilleure compréhension de ce qui fonctionne et comment cela fonctionne en ce moment.
** Afin de ne pas intégrer de conditions de compétition, il doit être programmé et révisé par un programmeur qui comprend le parallélisme **.
L'article recommande «Find Bugs» comme un outil partiellement mais efficace pour détecter les bogues de concurrence. "Spotbugs", le successeur de "FindBugs", a plusieurs éléments pour détecter les conditions de course. ("Manuel SpotBugs, Détails des bogues détectables")
Facebook a également publié ** «RacerD» **, un outil d'analyse statique des bogues de concurrence Java, en tant que logiciel open source en octobre 2017. Veuillez jeter un œil tel qu'il est présenté dans l'article suivant
J'ai essayé l'outil d'analyse de bogue de parallélisme Java "RacerD" créé par Facebook --Qiita
Résumé
- "** Traitement parallèle **" signifie traiter plusieurs threads en même temps dans un processus.
- "** Race condition **" est un bogue qui se produit lorsque des données qui n'étaient pas censées être accédées en même temps sont accédées en parallèle par plusieurs threads.
- Un programme qui fonctionne normalement même s'il est appelé à partir de plusieurs threads en même temps est exprimé par "** thread safe **".
- Les variables locales sont ** thread-safe. ** **
- Les variables d'instance, les variables de classe et les balises
<%!%>Ne sont ** pas thread-safe. ** ** - Les conditions de course sont difficiles à détecter lors des tests.
- La programmation et la révision doivent être effectuées par un programmeur qui comprend la concurrence.
- Il existe des "SpotBugs" et "RacerD" comme outils d'analyse statique pour les bogues parallèles qui sont partiellement mais efficaces.
Livre de référence
- "Introduction aux modèles de conception appris en langage Java, édition multithread, Softbank Creative" Un livre d'introduction sur les meilleures pratiques en programmation multithread. Il explique le modèle de mémoire de Java d'une manière très facile à comprendre.
- "Programmation de traitement parallèle Java - trouver sa" fondation "et sa" dernière API "-, Softbank Creative" Une lecture incontournable pour apprendre la simultanéité, écrite par Brian Goetz, l'architecte Java d'Oracle et leader de la concurrence Java.
Site de référence
- 『Java Concurrency in Practice』
Il s'agit d'un site Web où vous pouvez obtenir les meilleures pratiques de traitement parallèle et le code source des anti-modèles présentés dans "Java Parallel Processing Programming-Exploring the" Infrastructure "et" Latest API "-". - "" Traitement parallèle du codage sécurisé Java ", Codage sécurisé du centre de coordination JPCERT" Ceci est une directive pour la programmation de traitement parallèle publiée par JPCERT / CC.
Recommended Posts