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算法。