¿Qué es CAS?
El nombre completo de CAS es Compare-And-Swap (la implementación interna del bloqueo optimista)
Función: se utiliza para juzgar si el valor del valor de una determinada ubicación en la memoria es el valor esperado A, si lo es, cambia al nuevo valor B, todo el proceso de operación es una operación atómica
escenas a utilizar:
CAS está incorporado en el lenguaje Java que los diversos métodos de la clase sun.misc.Unsafe
llaman al método CAS en la clase UnSafe. La JVM nos ayudará a realizar la instrucción de ensamblaje CAS, que depende completamente de la función del hardware, porque CAS es una primitiva del sistema La primitiva pertenece a la categoría de sistema operativo. Está compuesta por varias instrucciones para completar un proceso de una determinada función, y la ejecución de la primitiva debe ser continua, y no se permite interrumpirla durante la ejecución, lo que significa que CAS es Una instrucción atómica de CPU no causará el llamado problema de inconsistencia de datos
A saber: CAS es seguro para subprocesos
Atributos centrales:
1. Clase básica insegura
Dado que los métodos Java no pueden acceder directamente al sistema operativo subyacente, es necesario acceder a ellos a través de métodos nativos. Inseguro es equivalente a una puerta trasera, según la cual se pueden manipular directamente datos específicos de la memoria. La clase Inseguro existe en el paquete sun.misc y sus métodos internos La operación puede manipular directamente la memoria como el puntero C
Debido a que todos los métodos de la clase Unsafe se modifican de forma nativa, pueden llamar directamente a los recursos subyacentes del sistema operativo para realizar las tareas correspondientes. La razón por la que la clase de empaquetado modificada Atomic puede garantizar la atomicidad depende de la clase insegura subyacente
2, variable valueOffset
Indica la dirección de offset de la variable valor en la memoria Inseguro obtiene los datos según la dirección de offset de memoria A través de la dirección de memoria valueOffset se puede obtener directamente el valor y luego se suma la operación.
3. El valor de la variable volátil modificada
Garantice la visibilidad de la memoria entre varios subprocesos
Durante la operación, debe comparar el valor en la memoria de operación y compararlo con el valor en la memoria principal
Si la comparación del valor Value y el valor esperado A devuelve falso, entonces el método while se ejecuta hasta que el valor esperado sea el mismo que el valor de memoria Valor
Sincronizado no se usa en la capa inferior, pero CAS se usa para mejorar la concurrencia y, al mismo tiempo, para lograr consistencia, porque después de que cada subproceso ingresa, ingresa al bucle do while y luego obtiene continuamente el valor en la memoria. Es necesario juzgar si Es la última operación y luego actualiza.
ejemplo:
假设线程A和线程B同时执行修改操作
1. value原始值为10，此时，线程A和线程B各自持有一份值为10的副本，分别存储在各自的工作内存
2. 当线程A拿到value值10的时候，CPU进行切换，线程A被挂起（失去CPU执行权）
3. 线程B也拿到Value值10，线程B并没有被挂起，接着执行了CAS方法，通过比较内存值正好为10，则表示成功，接着对内存值进行修改为15，至此，线程B修改操作完成
4. 之后线程A恢复，执行CAS方法，通过比较，发现自己副本获取到的值10和主内存中的数字15不一致，说明内存值已经被其它线程抢先一步修改，进而导致A线程本次修改失败，只能通过执行do while重新读取内存值后再进行CAS，因为内存值value被volatile修饰，所以其它线程对它的修改，线程A总能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。Esto implica una idea de giro, si la operación devuelve falso, girar hasta que la operación devuelva verdadero
Desventajas de CAS
1. Alta sobrecarga de CPU
Si hay una alta concurrencia, muchos subprocesos necesitan actualizar una variable, y la actualización no es exitosa muchas veces, y debido a que CAS es una operación de giro, se repiten bucles, lo que resulta en un tiempo demasiado largo, un consumo excesivo y mucha presión sobre la CPU. En el peor de los casos, el valor obtenido por un hilo es diferente del valor esperado, por lo que se repetirá indefinidamente.
2. CAS solo puede garantizar la atomicidad de nivel variable, no la atomicidad de los bloques de código
Cuando se realizan operaciones en una variable compartida, la operación atómica se puede garantizar mediante el bucle CAS, pero para múltiples operaciones de variables compartidas, el bucle CAS no puede garantizar la atomicidad de la operación. En este momento, solo se pueden usar bloqueos para garantizar la atomicidad.
3. Problema de ABA
CAS tendrá problemas de ABA en escenarios de subprocesos múltiples
ejemplo:
线程A，期望值为10，欲更新的值为15
线程B，期望值为10，欲更新的值为15
场景：
1.线程A抢先获得CPU时间片，而线程B因为其他原因阻塞
2.线程A取值与期望的值10比较，发现相等然后将值更新为15
3.这个时候出现了线程C，期望值为15，欲更新的值为10，线程C取值与期望的值15比较，发现相等则将值更新为10
4.此时线程B从阻塞中恢复过来，并且获得了CPU时间片，这时候线程B取值与期望的值10比较，发现相等则将值更新为15
虽然线程B也完成了操作，但是线程B并不知道这个值已经经过了10->15->10的变化过程。
Solución:
agregue el número de versión delante de la variable, el número de versión de la variable es +1 cada vez que se actualiza la variable, es decir, A-> B-> A se convierte en 1A-> 2B-> 3A
para resumir:
CAS (compareAndSwap)
Al comparar si el valor actual de la memoria de trabajo y el valor de la memoria física principal son iguales, si devuelve verdadero, realice la operación especificada, devuelva falso y luego continúe la comparación de giro hasta que los valores de la memoria principal y la memoria de trabajo sean consistentes