Mélanger volatile et synchronisée comme un verrou de lecture-écriture

Question

Considérons une variable de type primitif avec beaucoup de fils de lecture et quelques fils d'écriture, sera correctement?

travail le code suivant

S'il va, ne fournit de meilleures performances que 1). déclarant synchronisée sur toutes les méthodes; 2). en utilisant un ReadWriteLock explicite?

Est-ce un modèle commun? Dans le cas contraire, ce modèle est généralement utilisé dans cette situation?

Cela fonctionne actuellement bien pour moi, mais je pense qu'il est un peu redondant à utiliser à la fois volatile et synchronisée.

private volatile int value = 1;

public void func1()
{
    if (value == 1) {
        // do something
    }
}

public void func2()
{
    if (value == 2) {
        // do something
    }
}

public void func3()
{
    if (value == 3) {
        // do something
    }
}

public synchronized void increase()
{
    if (value < 10) value++;
}

public synchronized void decrease()
{
    if (value > 0) value--;
}

Answer 1

  

Considérons une variable de type primitif avec beaucoup de fils de lecture et quelques fils d'écriture, sera correctement?

travail le code suivant

Je pense que oui.

  

S'il va, ne fournit de meilleures performances que 1). déclarant synchronisée sur toutes les méthodes; 2). en utilisant un ReadWriteLock explicite?

Je pense que oui, à condition que les opérations de lecture plus nombreuses que les demandes d'écriture. Cependant:

• À moins que ce compteur est très soutenu, il n'a probablement pas d'importance. Ne perdez pas votre chose micro-optimisation du temps, sauf si vous avez la preuve qu'il est (ou sera) un goulot d'étranglement.
• Si cela est vraiment important pour vous, le benchmark.
• Ne soyez pas surpris si la performance relative dépend de versions JVM / niveaux de correctifs, les options JVM et matériel; par exemple. le nombre de processeurs et d'architecture de mémoire.

  

Est-ce un modèle commun? Dans le cas contraire, ce modèle est généralement utilisé dans cette situation?

Je ne sais pas si cela est commun. Mais mon sentiment est que l'approche la plus courante consiste à utiliser simplement une synchronisation régulière, et pas à vous inquiéter à ce sujet. Sauf si vous avez affaire à une structure de données très soutenu, la différence de performance entre les différentes approches sera négligeable à la performance globale de l'application.

Answer 2

Oui, il est courant, au moins à un certain degré:)

Le modèle que vous utilisez est décrit dans cet article IBM -> http://www.ibm.com/developerworks/java/library/j-jtp06197/index.html

(modèle n ° 5, verrou en lecture-écriture pas cher astuce)

Answer 3

Je suis sûr qu'il offre de meilleures performances, car il n'y a pas de blocage, mais si elle est correcte dépend de l'intention du code. Bien sûr, le comportement est différent du cas synchronisé. Que le comportement est similaire au cas de verrouillage dépend de l'endroit où vous verrouillez.