CAS算法

/**
 * CAS(Compare-And-Swap)算法保证了数据的原子性
 *          CAS算法是硬件对于并发操作共享数据的支持
 *          CAS包含了3个操作数:
 *          内存值 V  看成两步 读取内存值为1步
 *
 *          预估值 A  后面两步同时发生
 *          更新值 B
 *          当且仅当V == A时，V = B，否则不做任何操作
 * 下面用Java锁模拟CAS算法:
 */
public class CAS {


    private int value =0;

    public CAS() {
    }
    public CAS(int value) {
        this.value = value;
    }

    public synchronized int getValue() {
        return value;
    }

    private synchronized int compareAndSwap(int expectedValue, int newValue){
        int oldValue = value;
        if(oldValue == expectedValue)
            value = newValue;
        return oldValue;
    }

    public synchronized boolean compareAndSet(int expected, int newValue){
        return expected == compareAndSwap(expected, newValue);
    }
}

下面对于上面的CAS算法进行测试:

package volatile_1;

import java.util.ArrayList;
import java.util.List;

public class Test {

    private CAS cas = new CAS();
    @org.junit.Test
    public void Test() {
        List<Thread> threadList = new ArrayList<>();
        for(int i=0; i<100; ++i){//100个线程
            Thread t = new Thread(()->{
                for(int j=0; j < 10000; ++j){//每个线程将value值+10000
                    count();
                }
            });
            threadList.add(t);
        }

        threadList.forEach(Thread::start);//启动线程
        threadList.forEach(t->{//等待所有线程执行结束
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(cas.getValue());//打印value值，理论上为1000000
    }

    /**
     * 修改cas中的值
     */
    private void count(){
        while(true){
            int i= cas.getValue();
            boolean suc = cas.compareAndSet(i, ++i);//每次加一
            if(suc)
                break;
        }
    }
}

结果为:

1000000

说明通过Java代码模拟了CAS算法。