CAS的几个问题和模拟实现

compare and Swap,是一种区别于synchronized同步锁的一种乐观锁.

底层api中要四个值, 要操作的对象,内存偏移量,期望值,目标值.

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

更上层的接口只要内存值, 希望值,目标值即可.

CAS本质还是加锁,(只在赋值部分代码进行加锁),只是JDK使用JNI调用C语言方法调用cpu指令保证CAS是原子性的, 使用synchronized也可以自己模拟下CAS的实现, (本质还是加锁,内容相同则替换!!)

package com.zzk.data;

import java.util.concurrent.CountDownLatch;


public class CASDemo2 {

    public static volatile int count = 0;

    public void requestCas() {
        int expectValue;
        while (!compareAndSet((expectValue = getCount()), expectValue + 1)) {}
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized boolean compareAndSet(int expectValue, int targetValue) {
        if (expectValue == getCount()) {
            count = targetValue;
            return true;
        } else {
            return false;
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {

        int threadSize = 100;
        int perThreadRequestSize = 10;

        CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        CASDemo2 casDemo = new CASDemo2();
        for (int i = 0; i < threadSize; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i1 = 0; i1 < perThreadRequestSize; i1++) {
                        casDemo.requestCas();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        countDownLatch.await();

        System.out.println(CASDemo2.count);
    }
}

1. ABA 问题: 期待的值是A, 但是另一个线程将值变为B又变为A, 虽然值相等,但是后一个A已经不是第一个A了, 值变化了显然不能触发swap操作的,但是由于值还是A, 触发了swap操作. 所以这样是有问题的.
2. 大并发下,大多是线程都是在自旋,效率不行.

使用AtomicStampedReference类, 将值都给一个版本号, 这样就能区分A到底是哪个A了,