Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Modelo de memória de Java: happens-before e publicação segura

Aprende que escritas outras threads podem observar em Java SE 21, os limites de volatile, o bloqueio com dupla verificação e os modos de acesso de VarHandle.

Versão: Java SE 21

Sintaxe

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;
}

Em Java SE 21, o modelo de memória de Java (JMM) define de que escritas pode vir o valor lido por uma thread. A relação happens-before é transitiva e decorre da ordem do programa dentro de uma thread e das ligações de sincronização. Libertar um monitor precede todas as aquisições posteriores do mesmo monitor; escrever num campo volatile precede todas as leituras posteriores desse campo. Aqui, «posterior» refere-se à ordem de sincronização, não ao tempo do relógio. A chamada a start() precede as ações da thread iniciada, que precedem o regresso de join() após a sua terminação.

Há uma corrida de dados quando duas threads acedem à mesma variável, pelo menos um acesso é uma escrita e nenhum dos acessos precede o outro na relação happens-before. O escalonamento não determinístico é diferente: mesmo sem corridas de dados, a primeira thread a adquirir um bloqueio pode variar entre execuções.

A publicação segura torna visível o estado escrito antes de partilhar um objeto. Para publicar através de volatile, guarda a referência após a construção, não deixes escapar this antes do tempo e faz com que a thread recetora obtenha a referência publicada lendo o mesmo campo volatile. Também podes usar o mesmo monitor para escrever e ler ou publicar através da inicialização da classe. Visibilidade não é atomicidade: cada leitura ou escrita volatile é atómica, incluindo para long e double, cujos acessos normais podem observar metades de escritas diferentes. count++ continua a consistir numa leitura, numa soma e numa escrita separadas. volatile por si só não protege um invariante entre vários campos nem torna seguras as alterações posteriores ao objeto publicado.

No bloqueio com dupla verificação, lê volatile INSTANCE e verifica se é null fora de synchronized: após a inicialização, o caminho rápido não adquire o monitor. Se a leitura devolver null, adquire sempre o mesmo monitor Main.class, volta a ler INSTANCE e verifica de novo. Só se ainda for null deves construir o objeto e guardar a sua referência em INSTANCE. O bloqueio evita uma inicialização duplicada; volatile publica o objeto mesmo para o caminho rápido.

Em VarHandle, o modo plain (get/set) não impõe ordenação entre threads; por omissão, em plataformas de 32 bits não garante a atomicidade para long ou double, salvo indicação em contrário na documentação do método de fábrica. O modo opaque (getOpaque/setOpaque) oferece acesso atómico e coerente à mesma variável, mas não publica outros campos. Se getAcquire observar a escrita do setRelease correspondente na mesma variável, os acessos anteriores ao release ficam ordenados antes dos acessos posteriores ao acquire; não basta ter decorrido tempo. getVolatile/setVolatile acrescentam uma ordem total entre as operações no modo volatile. O modo escolhido é que conta: get continua a ser plain mesmo num campo declarado volatile.

Exemplos

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]);
    }
}

Resultado

same=true, values=42/42

Cada thread de trabalho lê diretamente o campo normal `value` e regista o resultado numa posição distinta do array. As duas chamadas a `join()` tornam os resultados visíveis para `main`; não publicam o objeto entre as threads de trabalho. A linha esperada, `same=true, values=42/42`, não indica qual das threads inicializou o objeto.

Lições relacionadas

  • Java · Lição 25 · Avançado · Versão: 2
  • Java · Lição 26 · Avançado · Versão: 2
  • Java · Lição 27 · Avançado · Versão: 2
  • Java · Lição 57 · Avançado · Versão: 2

Fontes