CAS原理浅析——自旋锁ABA情况的解决

喜欢ヅ旅行 2022-09-10 08:21 104阅读 0赞

马老师的分析：  
CAS锁 == 自旋锁：一直不断更新，直到没有人进来就更新成功，一直循环，成功为止。

1.  ABA问题：080，看着一样，但是其实不一样了（女朋友例子）  
    1 ）加版本，versionControl，给别人1回来变成999  
    2 ）boolean = markable
2.  保障CAS操作原子性问题：（lock指令），

造成ABA的原因：CAS是乐观锁，需要做很多防御措施（ｄｏｕｂｌｅ－ｌｏｃｋ）

public class BadTest {
        
        static int val = 0;
    
        public static void main(String[] args) throws InterruptedException {
        
            for (int j = 0; j < 1000; j++) {
        
                Thread thread = new Thread(() -> {
        
                    for (int i = 0; i < 10; i++) {
        
                        pulsVal();
                    }
                });
                thread.start();
            }
            Thread.sleep(500);
            System.out.println("最终val值为：" + val);
            Thread.sleep(500);
            System.out.println("最终val值为：" + val);
        }
        private static void pulsVal() {
        
            //正是因为有了前面的操作，才导致后面获取不到正确的值，因为与JVM中对val++ 的操作顺序有关
    //        TimeUnit.MILLISECONDS.sleep(5);
            val++;
        }
    }

![在这里插入图片描述][9254e0307aef405f85f83c330977c6a5.png]  
出现了遗漏的现象，因为他们没有排队的机制（sychronized），全部thread抢着进去，导致运算过程获取到中间的值，最终无法得到正确的结果。

## CAS模拟实现：val加到1000模拟操作 ##

提高并发性能：降低锁的粒度，只对val进行加锁

public class ModelTest {
        
        volatile private static int val = 0;
        public static void request() throws InterruptedException {
        
            TimeUnit.MILLISECONDS.sleep(5);
            int oldVal;
            while(!compareAndSwap((oldVal = getVal()),oldVal+1));
        }
    
        /**
         * @Param oldVal是我要改变的值
         * @Param newVal是我要变成的新值，这里进行比较看看能不呢替换，如果确实能替换，
         *        那么就在synchronized区域里面进行替换操作
         * */
        public synchronized static boolean compareAndSwap(int oldVal, int newVal) {
        
            if (getVal() == oldVal) {
        
                val = newVal;
                return true;
            }
            return false;
        }
        public static int getVal() {
        return val;}  //获得实时的值
        
        public static void main(String[] args) throws InterruptedException {
        
            //开始时间
            long startTime = System.currentTimeMillis();
            int threadSize = 100;
            CountDownLatch countDownLatch = new CountDownLatch(threadSize);
    
            for(int i = 0; i < threadSize; i++) {
        
    
                Thread thread = new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        //模拟用户行为，每个用户访问10次网站
                        try {
        
                            for(int j = 0; j < 10; j++) {
        
                                request();
                            }
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        } finally {
        
                            countDownLatch.countDown();
                        }
                    }
                });
    
                thread.start();
            }
            //怎么保证100个线程 结束之后，再执行后面代码？
            countDownLatch.await();
            long endTime = System.currentTimeMillis();
    
            System.out.println(Thread.currentThread().getName() + ",耗时：" + (endTime - startTime) + ", count = " + val);
        }
    }

## ABA的解决——添加版本信息 ##

两个值变成四个值，加多了版本控制  
出现了ABA的情况，如果对ABA不敏感，就无需对它进行额外的升级；解决办法：增加版本机制，AtomStampReference添加版本信息，reference、stamp  
CompareAndSet（期引，新引，期版本，新版本），必须要保证期望的引用和原来的一致，然后才能进入到加锁的版本更新方法中去 ，否则不能够进入更新方法，修改失败。

public class CasABADemo02 {
        
        public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1), 1);
    
        public static void main(String[] args) {
        
            Thread main = new Thread(() -> {
        
                    System.out.println("操作线程" + Thread.currentThread().getName() + ", 初始值：" + a.getReference());
                    try {
        
    
                        Integer expectReference = a.getReference();
                        Integer newReference = expectReference + 1;
                        Integer expectStamp = a.getStamp();
                        Integer newStamp = expectStamp + 1;
    
                        Thread.sleep(1000);//主线程休眠一秒钟，让出cpu
    
                        boolean isCASSccuess = a.compareAndSet(expectReference, newReference, expectStamp, newStamp);
                        System.out.println("操作线程" + Thread.currentThread().getName() + "，CAS操作：" + isCASSccuess);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
            }, "主线程");
    
            Thread other = new Thread(() -> {
        
                    try {
        
                        Thread.sleep(20);//确保Thread-main线程优先执行
    
                        a.compareAndSet(a.getReference(), (a.getReference() + 1), a.getStamp(), (a.getStamp() + 1));
                        System.out.println("操作线程" + Thread.currentThread().getName() + "，【increment】,值=" +a.getReference());
                        a.compareAndSet(a.getReference(), (a.getReference() - 1), a.getStamp(), (a.getStamp() + 1));
                        System.out.println("操作线程" + Thread.currentThread().getName() + "，【decrement】,值=" +a.getReference());
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
            }, "干扰线程");
    
            main.start();
            other.start();
        }
    }

![在这里插入图片描述][065ba366f60746338e7330f3c46113bf.png]  
other方法结束后，main方法对值进行操作，虽然值是期望的，但是版本号已经变为3了，所以不满足main方法的期望版本号一致——更新失败。

[9254e0307aef405f85f83c330977c6a5.png]: /images/20220829/51e7409028b146bda626786c5e194686.png
[065ba366f60746338e7330f3c46113bf.png]: /images/20220829/9a6a9baee6904dc3b1b9db0b16092607.png