Java volatile pour la concurrence

Question

Ok, donc je viens de lire cette question Do you ever use the volatile keyword in Java?, et j'utilise une variable volatile afin d'arrêter une boucle. J'ai aussi vu cette référence, http://www.javamex.com/tutorials/synchronization_volatile.shtml. Maintenant, l'article dit que les variables volatiles ne sont pas bloquantes. En outre, il dit qu'il ne peut pas être utilisé pour la concurrence dans une séquence lecture-mise à jour-écriture. Ce qui est logique parce qu'ils ne bloquent pas.

Puisque les variables volatiles ne sont jamais mises en cache, est-il plus rapide d'utiliser simplement la synchronisation pour arrêter la boucle (à partir du lien précédent)?

Edit: En utilisant une solution synchronisée

public class A{ 
    private boolean test; 

    public A(){ 
    test = true; 
    } 

    public synchronized void stop(){ 
    test = false; 
    } 

    public synchronized boolean isTrue(){ 
    return test; 
    } 
} 

public class B extends Thread { 
    private A a; 

    public B(A refA){ 
    a = refA; 
    } 

    public void run(){ 
    //Does stuff here 
    try{ 
     sleep(1000); 
    } 
    catch(Exception e){} 
    a.stop(); 
    } 

    public static void main(String [] args){ 
    A TestA = new A(); 
    B TestB = new B(TestA); 
    TestB.start(); 
    while(TestA.isTrue()){ 
     //stay in loop 
     System.out.println("still in loop"); 
    } 
    System.out.println("Done with loop"); 
    } 
} 

Answer 1

Non, la lecture d'une variable volatile est plus rapide que que la lecture d'une variable non volatile dans un bloc synchronized.

Un bloc synchronized efface les valeurs mises en cache à l'entrée, ce qui revient à lire une variable volatile. Mais, il vide également toutes les écritures mises en cache dans la mémoire principale lorsque le bloc synchronisé est quitté, ce qui n'est pas nécessaire lors de la lecture de la variable volatile.

Answer 2

Il y a un certain nombre de choses qui ne vont pas dans votre question: Vous pouvez faire une lecture-mise à jour-écriture fiable avec volatile tant que vous utilisez Atomic*FieldUpdater et une cas-loop. Les volatiles peuvent être "mis en cache", ils doivent juste obéir à la sémantique qui se produit avant la sémantique spécifiée.

La synchronisation implique généralement l'obtention d'un verrou, ce qui est relativement coûteux (bien que ce soit en fait assez bon marché). Les optimisations simultanées simples peuvent utiliser des techniques d'implémentation non naïves.