1.volatile

garantit qu'une fois les données partagées modifiées, elles seront immédiatement synchronisées avec la mémoire partagée (tas ou zone de méthode).

2. Le processus par lequel le thread accède aux données dans le tas

Le thread crée une copie de la variable dans la pile et synchronise les données dans la pile.

3. Réarrangement des instructions

Afin d'améliorer l'efficacité de l'exécution, le CPU réorganisera les instructions sans dépendances. Si vous souhaitez contrôler la réorganisation, vous pouvez utiliser volatile pour modifier une variable. Les instructions avant et après l'instruction contenant la variable sont triées indépendamment, et les instructions avant et après ne peuvent pas être ordonnées de manière croisée.

Deux problèmes et solutions courants

1. Problème d'atomicité

La soi-disant atomicité , Cela signifie qu'une opération ne peut pas être interrompue, c'est-à-dire que dans un environnement simultané multi-thread, une fois qu'une opération est démarrée, elle sera exécutée dans la même tranche de temps CPU . Si plusieurs opérations du même thread sont exécutées sur différentes tranches de temps CPU, en raison d'une stagnation au milieu, certaines données partagées peuvent être modifiées par d'autres threads lors d'opérations ultérieures, et la modification n'est pas synchronisée avec le thread actuel, ce qui entraîne les données. exploité par le thread actuel pour être incohérent avec les données réelles. Ce problème d'incohérence des données causé par une exécution incohérente est appelé un problème d'atomicité.

2. Problèmes de visibilité

Des problèmes de visibilité surviennent liés à la manière dont les fils de discussion accèdent aux données partagées. Lorsqu'un thread accède à une variable dans le tas (zone de méthode), il crée d'abord une copie

de la variable dans la pile, puis la synchronise avec le tas après modification. Si un thread vient de créer une copie, et qu'un autre thread modifie la variable, qui n'a pas encore été synchronisée avec le tas, alors il y aura un phénomène où deux threads exploitent la même variable dans le même état, tel que i=9 , la valeur initiale de la variable i est 9 et l'opération de chaque thread consiste à soustraire 1. Deux threads A et B accèdent aux variables en même temps. B exécute d'abord i-1 Avant de synchroniser le résultat i=8 avec le tas, le thread A exécute également i-1. À ce moment, l'état de i=9 est exécuté. Des problèmes de sécurité des threads se sont produits à deux reprises. Raison du problème de sécurité des threads : les modifications des données partagées par un thread ne peuvent pas être immédiatement vues par les autres threads.

volatile fournit une solution :

Une fois qu'un thread modifie les données partagées modifiées par volatile, la modification sera immédiatement synchronisée avec le tas, de sorte que lorsque les autres données accèdent aux données partagées
à partir du tas, elles obtiennent toujours la dernière valeur dans plusieurs threads. Défauts de volatile :

volatile ne peut garantir que lorsqu'un thread obtient des données du tas, il obtient la dernière valeur parmi tous les threads actuels If. un thread

a copié les données du tas. Avant que l'opération ne soit terminée, d'autres threads modifient les données. Les données modifiées ne seront pas synchronisées avec le thread actuel.

3. Problèmes d'ordre

Afin d'améliorer l'efficacité de l'exécution, le CPU réorganisera les instructions qui n'ont aucune dépendance après avoir réorganisé le résultat de l'exécution. est le même que le résultat de l’exécution séquentielle.

Par exemple, dans le code source :
int i=0;
int y=1;
Pendant l'exécution, le CPU peut d'abord exécuter "int y=1;" puis "int i=0;". Le résultat de l'exécution est le même que le résultat de l'exécution séquentielle.
La réorganisation des instructions est sûre dans un environnement monothread, mais des problèmes peuvent survenir dans un environnement multithread. Par exemple :
Sujet A :

s=new String("sssss");//指令1flag=false;//指令2

Copier après la connexion

Sujet B :

Si le thread A s'exécute séquentiellement, c'est-à-dire exécute l'instruction 1 puis exécute l'instruction 2, il n'y aura aucun problème avec l'exécution du thread B. Une fois les instructions réorganisées, si le thread A exécute d'abord l'instruction 2,
Ceci est flag=true, passe au thread 2, termine la boucle et exécute l'instruction 3. Puisque l'objet s n'a pas été encore créé, un pointeur nul apparaîtra anormal.
Raisons du problème de commande :

Un thread a des exigences séquentielles pour les opérations de modification d'autres threads sur les données partagées. Par exemple, le thread B nécessite le thread A. Exécutez d'abord l'instruction 1, , puis exécutez l'instruction 2. En raison du réarrangement des instructions, les instructions ne sont pas réellement exécutées dans l'ordre requis. À ce stade, des problèmes de sécurité des threads surviennent.

Solution :

Utiliser le mécanisme de synchronisation pour qu'un seul thread puisse accéder aux données partagées en même temps , ce qui est inefficace.
En utilisant volatile, une instruction contient des variables volatiles modifiées, alors l'ordre d'exécution de cette instruction reste inchangé, et les instructions avant et après cette instruction peuvent être indépendantes Réorganiser, le réarrangement croisé n'est pas possible.

Référence :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!