CAS原理机制分析

浅浅的花香味﹌ 2022-12-11 04:26 212阅读 0赞

# 一、CAS #

CAS是英文单词CompareAndSwap的缩写，中文意思是：**比较并替换**。CAS需要有3个操作数：**内存地址V**，**旧的预期值A**，**将要更新的目标值B**。

CAS指令执行时，**当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做**。整个比较并替换的操作是一个**原子操作**。

# 二、案例分析 #

## 1.普通多线程count自增运算CASTest1.java ##

package com.cas;
    
    public class CASTest1 { 
    	public static int count = 0;
    	// 创建5个线程，在每个线程当中让count自增100次
    	// 由于线程不安全，所以这段代码最终的运行结果中count很有可能会小于500
    	public static void main(String[] args) { 
    		for (int i = 0; i < 5; i++) { 
    			new Thread(new Runnable() { 
    				public void run() { 
    					try { 
    						Thread.sleep(10);
    					} catch (InterruptedException e) { 
    						e.printStackTrace();
    					}
    					for (int j = 0; j < 100; j++) { 
    						count++;
    					}
    				}
    			}).start();
    		}
    
    		try { 
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("count=" + count);
    	}
    }

CASTest1，多次计算结果，有可能值等于500，也有可能值小于500，异常结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center]

## 2.使用Synchronized同步锁，报障线程安全，count自增运算CASTest2.java ##

package com.cas;
    public class CASTest2 { 
    	public static int count = 0;
    	// 创建5个线程，在每个线程当中让count自增100次
    	// 使用Synchronized同步锁,报障线程安全，count最终结果等于500
    	public static void main(String[] args) { 
    		for (int i = 0; i < 5; i++) { 
    			new Thread(new Runnable() { 
    				public void run() { 
    					try { 
    						Thread.sleep(10);
    					} catch (InterruptedException e) { 
    						e.printStackTrace();
    					}
    					for (int j = 0; j < 100; j++) { 
    						synchronized (CASTest2.class) { 
    							count++;
    						}
    					}
    				}
    			}).start();
    		}
    
    		try { 
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("count=" + count);
    	}
    }

CASTest2.java计算结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 1]

## 3.使用Atomic操作类，提升性能，CASTest3.java ##

package com.cas;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class CASTest3 { 
    	public static AtomicInteger count = new AtomicInteger();
    	// 创建5个线程，在每个线程当中让count自增100次
    	// 使用AtomicInteger,Atomic操作类的底层正是用到了“CAS机制”,保障原子性操作，count最终结果等于500
    	public static void main(String[] args) { 
    		for (int i = 0; i < 5; i++) { 
    			new Thread(new Runnable() { 
    				public void run() { 
    					try { 
    						Thread.sleep(10);
    					} catch (InterruptedException e) { 
    						e.printStackTrace();
    					}
    					// 每个线程当中让count值自增100次
    					for (int j = 0; j < 100; j++) { 
    					    //使用incrementAndGet方法进行自增运算
    						count.incrementAndGet();
    					}
    				}
    			}).start();
    		}
    
    		try { 
    			Thread.sleep(1000);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    		System.out.println("count=" + count);
    	}
    }

CASTest3.java计算结果如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 2]

# 三、CAS底层原理分析 #

## 1.CAS和Synchronized对比 ##

Synchronized关键字会让没有得到锁资源的线程**进入Blocked状态**，而后在**争夺到锁资源后恢复为Runing状态**，这个过程中涉及到**操作系统用户模式和内核模式的转换，代价比较高**。  
另外，从思想上来说，**Synchronized属于悲观锁**，悲观的认为程序中的并发情况严重，所以**严防死守**。而**CAS属于乐观锁**，乐观地认为程序中的并发情况不那么严重，所以**让线程不断去重试更新**。

尽管**JAVA 1.6**之后为Synchronized做了优化，增加了**从偏向锁到轻量级锁再到重量级锁的过度**，但是在最终转变为重量级锁之后，性能仍然比较低（**Synchronized转变为重量级锁之前，也会采用CAS机制**）。所以面对这种情况，我们就可以使用Java中的**原子操作类**。

所谓原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类如AtomicBoolean，AtomicInteger，AtomicLong。它们分别用于Boolean，Integer，Long类型的原子性操作。而**Atomic操作类的底层正是用到了“CAS机制”。**

## 2.CAS的缺点 ##

**（1）CPU开销过大**  
在并发量比较高的情况下，如果**许多线程反复尝试更新某一个变量**，却又一直更新不成功，循环往复，会给CPU带来很到的压力。  
**（2）不能保证代码块的原子性**  
CAS机制所**保证的只是一个变量的原子性操作**，而不能保证整个代码块的原子性。比**如需要保证3个变量共同进行原子性的更新，就不得不使用Synchronized**了。  
**（3） ABA问题及解决方案**  
CAS 的使用流程通常如下：  
1）首先从内存地址 V 读取值 A；  
2）根据 A 计算目标值 B；  
3）通过 CAS 以原子的方式将地址 V 中的值从 A 修改为 B。

但是在第1步中读取的值是A，并且在第3步修改成功了，我们就能说它的值在第1步和第3步之间没有被其他线程改变过了吗？

比如**链表处理**，出现ABA时可能会掉链，因为虽然链表头指针相同，但是链表的后续节点值有可能不同。  
如果在这段期间它的值曾经被改成了B，后来又被改回为A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA”问题。

Java并发包为了解决**ABA问题**，提供了一个**带有标记的原子引用类**“AtomicStampedReference”，它可以通过**控制变量值的版本**来保证CAS的正确性。因此，在使用CAS前要考虑清楚“ABA”问题是否会影响程序并发的正确性，**如果需要解决ABA问题，改用传统的互斥同步可能会比原子类更高效**。

原子引用解决ABA问题代码案例

package com.zhang;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.concurrent.atomic.AtomicStampedReference;
    
    public class ABADemoTest { 
        //原子引用类，解决ABA问题
        static AtomicReference atomicReference = new AtomicReference(100);//初始值为100
        static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(100,1);//初始值为100，版本号为1
        public static void main(String[] args) { 
             System.out.println("以下是ABA问题的产生==========");
             new Thread(() ->{ 
                 atomicReference.compareAndSet(100,101);
                 atomicReference.compareAndSet(101,100);
             },"T1").start();
    
             new Thread(() -> { 
                 //暂停1秒，保证t1先执行，t2后执行
                 try { TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) { e.printStackTrace();}
                 System.out.println("这里产生了ABA问题，发现值被改成了2021，CAS结果为："+atomicReference.compareAndSet(100, 2021)+"\t"+atomicReference.get());
             },"T2").start();
    
             //暂停2秒
            try { TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) { e.printStackTrace();}
    
             System.out.println("以下是ABA问题的解决==========");
             new Thread(()->{ 
                 int stamp = atomicStampedReference.getStamp();//获取初始版本号
                 System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
                 try { TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) { e.printStackTrace();}
                 //4个参数分别为期望值、更新值、当前版本号、更新后版本号
                 atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);//执行CAS操作并更新版本号
                 System.out.println(Thread.currentThread().getName() + "\t第2次版本号：" + atomicStampedReference.getStamp());
                 atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);//执行CAS操作并更新版本号
                 System.out.println(Thread.currentThread().getName() + "\t第3次版本号：" + atomicStampedReference.getStamp());
             },"T3").start();
    
             new Thread(()->{ 
                int stamp = atomicStampedReference.getStamp();//获取初始版本号
                System.out.println(Thread.currentThread().getName() + "\t第1次版本号：" + stamp);
                try { TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) { e.printStackTrace();}
    
                boolean result = atomicStampedReference.compareAndSet(100,2021,stamp,stamp+1);//乐观认为数据100没有被改变，尝试执行将数据100更新成2021操作
                System.out.println(Thread.currentThread().getName()+"\t修改成功否："+result+"\t当前最新版本号："+atomicStampedReference.getStamp());
                System.out.println(Thread.currentThread().getName()+"\t当前实际最新值："+atomicStampedReference.getReference());
             },"T4").start();
    
        }
    }

执行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70]

## 3.CAS的底层实现 ##

**（1）针对案例3中CASTest3.java的incrementAndGet()方法**  
通过方法调用，我们可以发现，getAndIncrement()方法调用getAndAddInt()方法，最后调用的是compareAndSwapInt()方法。如下两张图片来自网上博客[getAndIncrement()方法][getAndIncrement]。  
![在这里插入图片描述][20200928161515509.png_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 3]  
getAndAddInt方法解析：拿到内存位置的最新值v，使用CAS尝试将内存位置的值修改为目标值v+delta，如果修改失败，则获取该内存位置的新值v，然后继续尝试（CAS的自旋操作），直至修改成功。  
用volatile关键字来保证（保证线程间的可见性）获取的当前值是内存中的最新值。

**（2）什么是unsafe呢？**  
Java语言不像C，C++那样可以直接访问底层操作系统，但是JVM为我们提供了一个后门，这个后门就是unsafe。unsafe为我们提供了硬件级别的原子操作。

至于valueOffset对象，是通过unsafe.objectFiledOffset方法得到，所代表的是AtomicInteger对象value成员变量在内存中的偏移量。我们可以简单的把valueOffset理解为value变量的内存地址。

我们上面说过，CAS机制中使用了3个**基本操作数**：内存地址V，旧的预期值A，要修改的新值B。

而unsafe的compareAndSwapInt方法的参数包括了这三个基本元素：valueOffset参数代表了V，expect参数代表了A，update参数代表了B。

正是unsafe的compareAndSwapInt方法保证了Compare和Swap操作之间的原子性操作。

**参考资料**  
https://blog.csdn.net/v123411739/article/details/79561458  
https://blog.csdn.net/Metis\_/article/details/79380378  
https://blog.csdn.net/qq\_32998153/article/details/79529704

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/3ad7b82880364d959a34112d13756f94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/1dd33f3915ac4268a1df494e0b76866c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/db5de94a74b44b94a55dc2612e230142.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70]: /images/20221123/8dfc3ed646b94b2d9ae92c4b12697726.png
[getAndIncrement]: https://blog.csdn.net/v123411739/article/details/79561458
[20200928161515509.png_pic_center]: /images/20221123/c69bf04fa02a46229cd9185a45d22dbf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppa2UxMTIzMQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/9060bff859f54cc5beb632d9bf55b5b5.png