Si l'accès aux données mutables partagées ne peut pas être synchronisé, les conséquences peuvent être désastreuses, même si la variable est lisible et inscriptible de manière atomique.
Considérons un problème de synchronisation des threads. Pour la synchronisation des threads, la bibliothèque de classes Java fournit la méthode Thread.stop, mais cette méthode ne vaut pas la peine d'être promue car elle est intrinsèquement dangereuse. Il serait préférable d'utiliser des sondages, comme le programme suivant.
Copiez le code comme suit :
importer java.util.concurrent.TimeUnit ;
classe publique StopThread {
/**
* @param arguments
*/
stopRequested booléen statique privé ;
public static void main (String[] arguments)
lance InterruptedException{
Thread backgroundThread = nouveau Thread (nouveau Runnable() {
@Outrepasser
public void run() {
int je = 0;
pendant que(!stopRequested){
je++;
System.out.println(i);
}
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
stopRequested = vrai ;
}
}
Vous pensez peut-être qu'après l'exécution de ce programme pendant environ une seconde, le thread principal définit stopRequested sur true, provoquant l'arrêt du nouveau thread en arrière-plan. En fait, ce n'est pas le cas, car le thread d'arrière-plan ne peut pas voir le changement. valeur, donc il continuera à boucler sans fin, c'est la conséquence de la non synchronisation des données. Alors faisons cela de manière synchrone.
Copiez le code comme suit :
importer java.util.concurrent.TimeUnit ;
classe publique StopThread {
/**
* @param arguments
*/
stopRequested booléen statique privé ;
demande d'annulation synchronisée statique privéeStop(){
stopRequested = vrai ;
}
booléen synchronisé statique privé stopRequested(){
retourner stopRequested ;
}
public static void main (String[] arguments)
lance InterruptedException{
Thread backgroundThread = nouveau Thread (nouveau Runnable() {
@Outrepasser
public void run() {
int je = 0;
pendant que(!stopRequested()){
je++;
System.out.println(i);
}
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
requestStop();
}
}
Cela permet d'obtenir une synchronisation des données. Il convient de noter que la méthode d'écriture (requestStop) et la méthode de lecture (stopRequested) doivent être synchronisées, sinon elles ne sont toujours pas synchronisées au vrai sens du terme.
De plus, nous pouvons utiliser le modificateur de variable volatile pour effectuer plus simplement les tâches de synchronisation.
Copiez le code comme suit :
importer java.util.concurrent.TimeUnit ;
classe publique StopThread {
/**
* @param arguments
*/
stopRequested booléen volatile statique privé ;
public static void main (String[] arguments)
lance InterruptedException{
Thread backgroundThread = nouveau Thread (nouveau Runnable() {
@Outrepasser
public void run() {
int je = 0;
pendant que(!stopRequested){
je++;
System.out.println(i);
}
}
});
backgroundThread.start();
TimeUnit.SECONDS.sleep(1);
stopRequested = vrai ;
}
}