Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Modèle mémoire de Java : happens-before et publication sûre

Découvrez quelles écritures un autre thread peut observer en Java SE 21, les limites de volatile, le verrouillage à double vérification et les modes de VarHandle.

Version : Java SE 21

Syntaxe

private static volatile Payload INSTANCE;

static Payload instance() {
    Payload result = INSTANCE;
    if (result == null) {
        synchronized (Main.class) {
            result = INSTANCE;
            if (result == null) {
                result = new Payload();
                INSTANCE = result;
            }
        }
    }
    return result;
}

Dans Java SE 21, le modèle mémoire de Java (JMM) définit de quelles écritures peut provenir la valeur lue par un thread. La relation happens-before est transitive et découle de l'ordre du programme dans un thread et des liens de synchronisation. La libération d'un moniteur précède toute acquisition ultérieure de ce même moniteur ; une écriture dans un champ volatile précède toute lecture ultérieure de ce champ. « Ultérieure » se rapporte ici à l'ordre de synchronisation, pas à l'horloge. L'appel à start() précède les actions du thread démarré, et ces actions précèdent le retour de join() après sa terminaison.

Il y a une course aux données quand deux threads accèdent à la même variable, qu'au moins un accès est une écriture et que la relation happens-before n'ordonne pas ces accès. L'ordonnancement non déterministe est autre chose : même sans course aux données, le premier thread à obtenir un verrou peut varier d'une exécution à l'autre.

La publication sûre rend visible l'état écrit avant le partage d'un objet. Pour publier via volatile, stockez la référence après la construction, ne laissez pas this s'échapper prématurément et faites lire au thread destinataire la référence publiée dans le même champ volatile. On peut aussi utiliser le même moniteur pour l'écriture et la lecture, ou publier via l'initialisation d'une classe. Visibilité et atomicité sont distinctes : chaque lecture ou écriture volatile est atomique, y compris pour long et double, dont les accès ordinaires peuvent lire des moitiés issues d'écritures différentes. count++ reste une lecture, une addition puis une écriture. volatile seul ne protège ni un invariant portant sur plusieurs champs ni les modifications ultérieures de l'objet publié.

Pour le verrouillage à double vérification, lisez volatile INSTANCE et testez null hors de synchronized : après l'initialisation, le chemin rapide ne prend pas le verrou du moniteur. Si la lecture donne null, prenez toujours le même moniteur Main.class, relisez INSTANCE et vérifiez à nouveau. Ne construisez l'objet et n'affectez sa référence à INSTANCE que si la valeur est toujours null. Le verrou évite l'initialisation en double ; volatile assure la publication même sur le chemin rapide.

Avec VarHandle, le mode plain (get/set) n'impose pas d'ordre entre threads ; par défaut, il ne garantit pas non plus l'atomicité de long et double sur une plateforme 32 bits, sauf indication contraire de la méthode de fabrique. Le mode opaque (getOpaque/setOpaque) offre des accès atomiques et cohérents à la même variable, sans publier d'autres champs. Si getAcquire observe l'écriture du setRelease correspondant sur la même variable, les accès précédant le release sont ordonnés avant les accès suivant l'acquire ; l'ordre chronologique ne suffit pas. getVolatile/setVolatile ajoutent un ordre total entre les opérations en mode volatile. Le mode choisi fait foi : get reste plain même sur un champ déclaré volatile.

Exemples

public class Main {
    private static volatile Payload INSTANCE;

    private static final class Payload {
        private int value;

        private Payload() {
            value = 42;
        }
    }

    static Payload instance() {
        Payload result = INSTANCE;
        if (result == null) {
            synchronized (Main.class) {
                result = INSTANCE;
                if (result == null) {
                    result = new Payload();
                    INSTANCE = result;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) throws InterruptedException {
        Payload[] references = new Payload[2];
        int[] values = new int[2];
        Thread first = new Thread(() -> {
            Payload result = instance();
            references[0] = result;
            values[0] = result.value;
        });
        Thread second = new Thread(() -> {
            Payload result = instance();
            references[1] = result;
            values[1] = result.value;
        });

        first.start();
        second.start();
        first.join();
        second.join();

        System.out.println("same=" + (references[0] == references[1])
                + ", values=" + values[0] + "/" + values[1]);
    }
}

Résultat

same=true, values=42/42

Chaque thread de travail lit lui-même le champ ordinaire `value` et consigne le résultat dans une case distincte. Les deux appels à `join()` rendent les résultats visibles à `main` ; ils ne publient pas l’objet d’un thread de travail à l’autre. La ligne attendue, `same=true, values=42/42`, n’indique pas quel thread a initialisé l’objet.

Leçons associées

  • Java · Leçon 25 · Avancé · Version : 2
  • Java · Leçon 26 · Avancé · Version : 2
  • Java · Leçon 27 · Avancé · Version : 2
  • Java · Leçon 57 · Avancé · Version : 2

Sources