Compreensão profunda de CAS e referências atômicas
Um, entendimento profundo de CAS
O que é CAS
ublic class CASDemo {
//CAS compareAndSet:比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
// 期望、更新
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！
// ============== 捣乱的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020,2021));
System.out.println(atomicInteger.get());
//atomicInteger.getAndIncrement();
System.out.println(atomicInteger.compareAndSet(2021,2020));
System.out.println(atomicInteger.get());
// ============== 期望的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020,6666));
System.out.println(atomicInteger.get());
}
}
classe insegura
Memória de operação de palavras atrás da figura acima
CAS: compare o valor na memória de trabalho atual com o valor na memória principal, se esse valor for esperado, execute a operação! Se não for, continue o loop!
Desvantagens:
1. O ciclo será demorado
2. Apenas uma vez pode garantir a atomicidade de uma variável compartilhada
3. Problema ABA
CAS: problema ABA (gato civet para príncipe)
public class CASDemo {
// CAS compareAndSet 比较并交换
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
// 期望、更新
// public final boolean compareAndSet(int expect, int update)
// 如果期望得值成功了，那么就更新，否则就不更新 CAS是CPU的并发原语。
// ============== 捣乱的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
// ============== 期望的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020, 6666));
System.out.println(atomicInteger.get());
}
}
2. Citação atômica
Resolva o problema ABA e introduza referências atômicas! Pensamento correspondente: bloqueio otimista!
Operação atômica com número de versão!
public class CASDemo {
// AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题，范围内用同一个，超出自动new新的
// 正常在业务操作，这里面比较的都是一个个对象
static AtomicStampedReference<Integer> atomicStampedReference = new
AtomicStampedReference<>(1, 1);
// CAS compareAndSet : 比较并交换！
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("a1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1);
System.out.println("a2=>" + atomicStampedReference.getStamp());
System.out.println(atomicStampedReference.compareAndSet(2, 1,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1));
System.out.println("a3=>" + atomicStampedReference.getStamp());
}, "a").start();
// 乐观锁的原理相同！
new Thread(() -> {
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("b1=>" + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 6,
stamp, stamp + 1));
System.out.println("b2=>" + atomicStampedReference.getStamp());
}, "b").start();
}
}
Nota:
Integer usa o mecanismo de cache de objeto, o intervalo padrão é -128 ~ 127, é recomendado usar o método estático de fábrica valueOf para obter instâncias de objeto em vez de new, porque valueOf usa cache, e new definitivamente criará novos objetos e alocará nova memória espaço;
