CKTIS / Java
VarHandle: leitura acquire, escrita release e CAS atómico
Em Java SE 21, podes obter um handle para um campo `int` comum, escolher a ordenação de memória nas leituras e escritas e atualizar o valor de forma condicional e atómica.
Versão: Java SE 21
Sintaxe
VarHandle handle = MethodHandles.lookup().findVarHandle(VarHandleDemo.class, "state", int.class);
int observed = (int) handle.getAcquire(demo);
handle.setRelease(demo, newValue);
boolean updated = handle.compareAndSet(demo, expectedValue, newValue);Em java.lang.invoke, MethodHandles.lookup() devolve um objeto de pesquisa com as permissões de acesso da classe que faz a chamada. MethodHandles.Lookup.findVarHandle recebe a classe do recetor onde começa a pesquisa, bem como o nome e o tipo exato do campo de instância (int.class, não Integer.class). Essa classe pode ser uma subclasse que herda o campo, desde que o objeto de pesquisa tenha acesso ao campo. O handle não fica associado a um objeto: passa a instância como primeiro argumento de cada operação. Para um campo estático, usa findStaticVarHandle; as suas operações não recebem uma instância.
O acesso é verificado ao criar o handle. Se não existir um campo com o nome e o tipo indicados, é lançada NoSuchFieldException. Se o acesso for negado ou findVarHandle encontrar um campo estático, é lançada IllegalAccessException. Não passes um handle para um campo privado a código não fidedigno: poderia usá-lo sem nova verificação de acesso ao campo.
setRelease(obj, value) escreve com ordenação release e (int) handle.getAcquire(obj) lê com ordenação acquire. Se a leitura acquire observar a escrita release no mesmo campo, os acessos à memória anteriores à escrita ficam ordenados antes dos posteriores à leitura. A leitura não espera por um valor mais recente. A ordenação vem do modo do handle: o campo int comum não precisa de ser volatile, e lê-lo diretamente não tem semântica acquire.
compareAndSet(obj, expected, update) compara o int atual com == e, se coincidir, escreve o novo valor e devolve true, tudo de forma atómica. Caso contrário, devolve false sem escrever. A leitura e, em caso de sucesso, a escrita têm semântica volatile. Os métodos de acesso têm assinatura polimórfica: apesar de Object... nas declarações, os tipos no ponto de chamada, incluindo a conversão explícita (int) do resultado, determinam o descritor da chamada. Um tipo incompatível pode causar WrongMethodTypeException, uma conversão de referência falhada pode causar ClassCastException e um modo não suportado (como escrever num campo final) lança UnsupportedOperationException.
Exemplos
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
public class VarHandleDemo {
private int state;
public static void main(String[] args) throws ReflectiveOperationException {
VarHandle stateHandle = MethodHandles.lookup()
.findVarHandle(VarHandleDemo.class, "state", int.class);
VarHandleDemo demo = new VarHandleDemo();
stateHandle.setRelease(demo, 1);
int observed = (int) stateHandle.getAcquire(demo);
boolean updated = stateHandle.compareAndSet(demo, observed, 2);
boolean staleUpdate = stateHandle.compareAndSet(demo, 1, 3);
int finalState = (int) stateHandle.getAcquire(demo);
System.out.println("observed=" + observed);
System.out.println("updated=" + updated);
System.out.println("staleUpdate=" + staleUpdate);
System.out.println("finalState=" + finalState);
}
}Resultado
observed=1 updated=true staleUpdate=false finalState=2
Numa só thread, o programa escreve `1`, lê `1`, muda o valor para `2` através de CAS e rejeita a segunda tentativa, que ainda espera `1`. A saída mostra as chamadas, não a visibilidade entre threads.
Lições relacionadas
- Java · Lição 57 · Avançado · Versão: 2