JUC线程高级---原子变量与CAS算法

**版权声明：本文为小斑马伟原创文章，转载请注明出处！

原子变量：类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类。
类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。
AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。
java.util.concurrent.atomic 包下提供了一些原子操作的常用类:
AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference
AtomicIntegerArray 、AtomicLongArray
AtomicMarkableReference
AtomicReferenceArray
AtomicStampedReference

i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”。如果只用volatile使共享数据可见，还是出现i++写操作与读的实际结果值与预估值不一致现象。因此还需要增加原子性，不可分割一步操作。

/*
 * 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
 *        int i = 10;
 *        i = i++; //10
 * 
 *        int temp = i;
 *        i = i + 1;
 *        i = temp;
 * 
 * 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
 *      1. volatile 保证内存可见性
 *      2. CAS（Compare-And-Swap） 算法保证数据变量的原子性
 *          CAS 算法是硬件对于并发操作的支持
 *          CAS 包含了三个操作数：
 *          ①内存值  V
 *          ②预估值  A
 *          ③更新值  B
 *          当且仅当 V == A 时， V = B; 否则，不会执行任何操作。
 */
public class TestAtomicDemo {

  public static void main(String[] args) {
      AtomicDemo ad = new AtomicDemo();
    
      for (int i = 0; i < 10; i++) {
          new Thread(ad).start();
      }
  }

}

class AtomicDemo implements Runnable{

 // private volatile int serialNumber = 0;

private AtomicInteger serialNumber = new AtomicInteger(0);

@Override
public void run() {
    
    try {
        Thread.sleep(200);
    } catch (InterruptedException e) {
    }
    
    System.out.println(getSerialNumber());
}

public int getSerialNumber(){
    return serialNumber.getAndIncrement();
}
}

CAS 算法：CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。
CAS 是一种无锁的非阻塞算法的实现。
CAS 包含了3 个操作数：

• 1 需要读写的内存值V
• 2 进行比较的值A
• 3 拟写入的新值B

当且仅当V 的值等于A 时，CAS 通过原子方式用新值B 来更新V 的值，否则不会执行任何操作。
模拟 CAS 算法

/*
 * 模拟 CAS 算法
 */
public class TestCompareAndSwap {

public static void main(String[] args) {
    final CompareAndSwap cas = new CompareAndSwap();
    
    for (int i = 0; i < 10; i++) {
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                int expectedValue = cas.get();
                boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
                System.out.println(b);
            }
        }).start();
    }
  } 
}

class CompareAndSwap{
private int value;

//获取内存值
public synchronized int get(){
    return value;
}

//比较
public synchronized int compareAndSwap(int expectedValue, int newValue){
    int oldValue = value;
    
    if(oldValue == expectedValue){
        this.value = newValue;
    }
    
    return oldValue;
}

//设置
public synchronized boolean compareAndSet(int expectedValue, int newValue){
    return expectedValue == compareAndSwap(expectedValue, newValue);
}
}