Cet article analyse l'utilisation du multi-thread volatile et synchronisé dans Java avec des exemples. Partagez-le avec tout le monde pour votre référence. La méthode spécifique de mise en œuvre est la suivante :
Copiez le code comme suit : package com.chzhao ;
la classe publique Volatiletest étend le fil {
nombre d'ints statiques privés = 0 ;
public void run() {
compte++;
}
public static void main (String[] arguments) {
Fils de discussion[] = nouveau fil[10000] ;
pour (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
pour (int i = 0; i < threads.length; i++) {
fils[i].start();
}
essayer {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Le code est comme ci-dessus. La sortie attendue est 10 000. Cependant, comme count++ n'est pas thread-safe, la sortie sera souvent inférieure à 10 000.
Pour résoudre ce problème, le mot clé volatile a été ajouté.
Copiez le code comme suit : package com.chzhao ;
la classe publique Volatiletest étend le fil {
nombre d'ints statiques volatiles privés = 0 ;
public void run() {
compte++;
}
public static void main (String[] arguments) {
Fils de discussion[] = nouveau fil[10000] ;
pour (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
pour (int i = 0; i < threads.length; i++) {
fils[i].start();
}
essayer {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Après modification, des valeurs autres que 10 000 sont souvent affichées.
Modifiez-le sous forme synchronisée, le code est le suivant :
Copiez le code comme suit : package com.chzhao ;
la classe publique SynchronizedTest étend le fil {
nombre d'ints statiques privés = 0 ;
public void run() {
synchronisé (LockClass.lock) {
compte++;
}
}
public static void main (String[] arguments) {
Fils de discussion[] = nouveau fil[10000] ;
pour (int i = 0; i < threads.length; i++) {
threads[i] = new SynchronizedTest();
}
pour (int i = 0; i < threads.length; i++) {
fils[i].start();
}
essayer {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Copiez le code comme suit : package com.chzhao ;
classe publique LockClass {
public static byte[] lock = nouvel octet[0];
}
Après cette modification, le résultat est de 10 000.
Cela signifie-t-il que le mot-clé volatile est totalement inutile ? Seule la synchronisation peut garantir la sécurité des threads ?
illustrer:
Le langage Java contient deux mécanismes de synchronisation inhérents : les blocs (ou méthodes) synchronisés et les variables volatiles. Les deux mécanismes sont proposés pour assurer la sécurité des threads de code. Les variables volatiles sont moins synchronisées (mais parfois plus simples et moins coûteuses), et leur utilisation est également plus sujette aux erreurs. Les variables volatiles dans le langage Java peuvent être considérées comme « moins synchronisées » ; par rapport aux blocs synchronisés, les variables volatiles nécessitent moins de codage et ont moins de temps d'exécution, mais elles peuvent atteindre une fonctionnalité qui n'est qu'une partie de la synchronisation.
En d'autres termes, dans certains cas, volitile est plus pratique à utiliser que synchronisé, mais bien sûr, la synchronisation est pire.
J'espère que cet article sera utile à la programmation Java de chacun.