原子操作CAS及其实现类，你还搞不定分布式系统流控、熔断吗

        boolean suc = atomicCount.compareAndSet(i, ++i);
        if (suc) {
            break;
        }
    }
}

public static void main(String[] args) {
    Counter cas = new Counter();
    List<Thread> ts = new ArrayList<>(500);
    long start = System.currentTimeMillis();
    for (int j = 0; j < 100; j++) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                cas.safeCount();
            }
        });
        ts.add(t);
    }
    for (Thread t : ts) {
        t.start();
    }
    for (Thread t : ts) {
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println(cas.i);
    System.out.println(cas.atomicCount.get());
    System.out.println(System.currentTimeMillis() - start);
}

}

![](https://upload-images.jianshu.io/upload_images/15590149-503e22a1e34d1bba?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)  
CAS是怎么实现线程的安全呢？语言层面不做处理，我们将其交给硬件—CPU和内存，利用CPU的多处理能力，实现硬件层面的阻塞，再加上volatile变量的特性（可见性，有序性）即可实现基于原子操作的线程安全。
#### CAS实现原子性操作的三大问题
在Java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作，比如LinkedTransferQueue类的xfer方法。CAS虽然很高的解决了原子操作，但是CAS仍然存在三大问题。ABA问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。
##### ABA问题
因为CAS需要在操作值的时候，检查值有没有发生变化，如果发生变化则更新，但是如果一个值为A，变成了B，又变成了A，那么使用CAS进行检查时就会发现它的值没有发生变化，但实际上发生变化了。ABA问题的解决思路就是使用版本号，在变量前边追加版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。从java1.5开始，JDK提供了AtomicStampedReference、AtomicMarkableReference来解决ABA的问题，通过compareAndSet方法检查值是否发生变化以外检查版本号知否发生变化。（AtomicStampedReference能够得到变化的次数这里下边会介绍到）
##### 循环时间长开销大
自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。
##### 只能保证一个共享变量的原子操作 
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。
### Jdk中相关原子操作类的使用
从1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean、AtomicInter。这些原子包装类还提供了简单、性能高效、线程安全有用的工具方法，并且
在并发代码来说是非常关键的。原子变量将发生在单个的变量上，粒度最细的情况。原子变量类有很多种，所以Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性。Atomic包里的类基本都是通过Unsafe实现包装类。

#### 原子更新基本类型
使用原子方式更新基本类型，Atomic包提供了以下3个类。  
AtomicBoolean：原子更新布尔值类型  
AtomicInteger：原子更新整型  
AtomicLong：原子更新长整形  
以AtomicInteger为例：  

public final int addAndGet(int delta)

以原子方式将输入的数值与实例的值相加，并返回结果。

public final boolean compareAndSet(int expect, int update)

如果输入的数值等于预期值，则以原子的方式设置输入的值。

public final int getAndIncrement()

以原子方式将当前值加1，注意，这里返回的是自增前的值。

public final int getAndSet(int newValue)

以原子方式设置为newValue的值，并返回旧值。   
接下来我们看一下getAndIncrement源码

public final int getAndIncrement()

以原子方式将当前值设置为1，这里返回的是自增的值。
在JDK1.8中getAndIncrement是如何实现原子操作的呢？我们分析一下源码，

public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}

public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}

getAndIncrement方法调用了首先Unsafe的getAndAddInt方法，获取当前数值，然后循环compareAndSwapObject验证v和delta是否相等如果不相等返回v，这里意味着A tmoicInteger值是否修改过。  
接下来我们看Unsafe类

//更新变量值为x，如果当前值为expected
//o：对象 offset：偏移量 expected：期望值 x：新值
public final native boolean compareAndSwapObject(Object o,
long offset,
Object expected,
Object x);
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
public final native boolean compareAndSwapLong(Object o, long offset,
long expected,
long x);

通过代码，我们发现Unsafe只提供了3种CAS方法：compareAndSwapObject、compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现它是先把Boolean转换成整
型，再使用compareAndSwapInt进行CAS，所以原子更新char、float和double变量也可以用类似
的思路来实现。

#### 原子更新数组
通过原子的方式更新数组里的某个元素，Atomic包提供了以下四个类。  
AtomicIntegerArray：原子更新整型数组里的元素。  
AtomicLongArray：原子更新长征信数组里的元素。  
AtomicReferenceArray：原子更新引用类型数组里的元素。  
以AtomicIntegerArray为例，AtomicIntegerArray的使用实例代码如下

public class AtomicIntegerArrayTest {
static int[] value = new int[] { 1， 2 };
static AtomicIntegerArray ai = new AtomicIntegerArray(value);

public static void main(String[] args) {
ai.getAndSet(0， 3);
System.out.println(ai.get(0));
System.out.println(value[0]);
}
}

输出的结果是3和1，这里要注意的是数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组
复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。  
#### 原子更新引用类型
原子更新基本类型的AtomicInteger，只能更新一个变量，则需要使用这个原子引用类型提供的类。  
AtomicReference：原子更新引用类型。  
AtomicReferenceFieldUpdater：原子更新引用类型里的字段。  
AtomicMarkableReference：原子更新带有标记的引用类型，可以以原子更新一个布尔类型的标志位和引用类型。
以AtomicReference为例，AtomicReference的使用示例代码如下  

public class AtomicReferenceTest {
public static AtomicReference atomicUserRef = new
AtomicReference();

  public static void main(String[] args) {
      User user = new User("tim"， 15);
      atomicUserRef.set(user);
      User updateUser = new User("jack"， 17);
      atomicUserRef.compareAndSet(user， updateUser);
      System.out.println(atomicUserRef.get().getName());
      System.out.println(atomicUserRef.get().getOld());
  }

《MySql面试专题》

《MySql性能优化的21个最佳实践》

《MySQL高级知识笔记》

文中展示的资料包括：**《MySql思维导图》《MySql核心笔记》《MySql调优笔记》《MySql面试专题》《MySql性能优化的21个最佳实践》《MySq高级知识笔记》**如下图

CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】

ySql调优笔记》《MySql面试专题》《MySql性能优化的21个最佳实践》《MySq高级知识笔记》**如下图

[外链图片转存中…(img-o7AazRJN-1630679889483)]

CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】

关注我，点赞本文给更多有需要的人