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

CKTIS / Java

volatile — visibilité d’un champ entre threads

volatile est un mot-clé réservé qui marque un champ utilisé pour communiquer entre threads. Il garantit la visibilité et l’ordre happens-before, mais n’assure ni l’exclusion mutuelle ni l’atomicité d’opérations telles que count++.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

[accessModifier] [static] volatile Type fieldName [= initializer];

volatile est un mot-clé réservé de Java SE 21 et un modificateur applicable à un champ d’instance ou à un champ static. Il ne peut pas s’appliquer aux variables locales, aux paramètres ou aux méthodes. Combiner final et volatile sur le même champ constitue une erreur de compilation. Les crochets de la syntaxe indiquent des éléments facultatifs, et non du code Java littéral.

Une écriture dans un champ volatile est dans une relation happens-before avec toute lecture ultérieure de ce même champ ; « ultérieure » se rapporte à l’ordre de synchronisation. Par transitivité de cette relation, les écritures antérieures effectuées par le thread qui écrit deviennent visibles pour le thread qui lit après la lecture volatile correspondante. Cela ne garantit pas qu’un autre thread s’exécutera immédiatement.

volatile ne prend pas de verrou. Même si les lectures et écritures individuelles sont atomiques, count++ combine une lecture, un calcul et une écriture ; des incréments concurrents peuvent donc entraîner la perte de mises à jour. Si un seul thread écrit dans count, count++ reste non atomique, mais aucune mise à jour ne peut être perdue à cause d’une écriture d’un autre thread. Pour un champ de référence, volatile s’applique à la référence, pas automatiquement aux champs de l’objet ni aux éléments du tableau. Une seule référence volatile peut néanmoins servir à publier un instantané immuable qui préserve un invariant portant sur plusieurs champs. Un thread qui lit la référence une seule fois et récupère toutes les valeurs pertinentes dans ce même instantané observe un état cohérent sans synchronisation supplémentaire.

Dans l’exemple, value = 42 précède ready = true. Dès que la boucle lit true, la lecture ultérieure de value doit renvoyer 42, même si value n’est pas volatile. L’appel à join() n’a lieu qu’après l’affichage et n’établit donc pas cette visibilité. L’attente active consomme du temps processeur ; il s’agit d’un exemple pédagogique, et non d’une méthode d’attente à utiliser par défaut en production. volatile ne garantit ni une répartition équitable du processeur ni une durée d’attente limitée.

Exemples

public class VolatileDemo {
    private static int value;
    private static volatile boolean ready;

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            value = 42;
            ready = true;
        });
        writer.start();

        while (!ready) {
            // Wait for publication.
        }
        System.out.println(value);
        writer.join();
    }
}

Résultat

42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources