原子类及CAS

1、原子类的作用

能够保证线程安全，优点：相对于锁粒度更细（变量级别）；通过CAS实现，在竞争更不激烈的情况下效率更高。

2、原子类纵览

 3、基本类型原子类：AtomicInteger常用方法

 （1）常规的获取和赋值：get()，set()，getAndset()

 （2）基于CAS的赋值：compareAndSet(int,int)  在比较与预期值相同时进行赋值，并返回赋值操作的是否成功

（3）线程安全的i++,i--: getAndIncrement()和getAndDecrement()

（4）线程安全的++i,--i：incrementAndGet()和decrementAndGet()

4、数组类型原子类：AtomicIntegerArray常用方法

 数组中每个元素都是线程安全的，方法与AtomicInteger相似只是多加了一个下标index

5、将类中的普通属性升级为具有原子功能，AtomicIntegerFieldUpdater

代码实例：

package atomicandcas;

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterDemo implements Runnable {
    private Student student1;
    private Student student2;
    //AtomicIntegerFieldUpdaterb本质上是一个工具类，
    //通过newUpdater()使用映射创建一个能对一个类的一个int类型的字段进行原子操作的工具
    private static AtomicIntegerFieldUpdater<Student> updater =
            AtomicIntegerFieldUpdater.newUpdater(Student.class,"score");

    public AtomicIntegerFieldUpdaterDemo(Student student1, Student student2) {
        this.student1 = student1;
        this.student2 = student2;
    }
    public static void main(String[] args) throws InterruptedException {
        Student s1=new Student("Marry",0);
        Student s2=new Student("Tom",0);
        AtomicIntegerFieldUpdaterDemo demo=new AtomicIntegerFieldUpdaterDemo(s1,s2);
        Thread thread1=new Thread(demo);
        Thread thread2=new Thread(demo);
        thread1.start();
        thread2.start();
        Thread.sleep(500);
        System.out.println(demo.student1.name+":"+demo.student1.score);
        System.out.println(demo.student2.name+":"+demo.student2.score);
    }
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            this.student1.score++;
            //通过 updater.getAndIncrement(要进行原子操作的对象) 来实现原子的i++
            updater.getAndIncrement(student2);
        }
    }
}

class  Student{
    public String name;
    //进行原子操作的字段 必须是volatile修饰的基本类型（不能是装饰类）
    public volatile int score;

    public Student(String name, Integer score) {
        this.name = name;
        this.score = score;
    }
}

6、LongAdder累加器和AtomicLong的比较

package atomicandcas;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;

public class AtomicLongDemo {
    private static AtomicLong adder=new AtomicLong();

    public static void main(String[] args) {
        ExecutorService threadPool= Executors.newFixedThreadPool(100);
        long start=System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            threadPool.submit(()->{
                for (int j = 0; j < 10000; j++) {
                    adder.getAndIncrement();
                }
            });
        }
        threadPool.shutdown();
        while (!threadPool.isTerminated()){

        }
        long end=System.currentTimeMillis();
        System.out.println(adder.get());
        System.out.println("耗时（ms）:"+(end-start));
    }
}

package atomicandcas;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.LongAdder;

public class LongAdderDemo {
    private static  LongAdder adder=new LongAdder();

    public static void main(String[] args) {
        ExecutorService threadPool= Executors.newFixedThreadPool(100);
        long start=System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            threadPool.submit(()->{
                for (int j = 0; j < 10000; j++) {
                    adder.increment();
                }
            });
        }
        threadPool.shutdown();
        while (!threadPool.isTerminated()){

        }
        long end=System.currentTimeMillis();
        System.out.println(adder.sum());
        System.out.println("耗时（ms）:"+(end-start));
    }
}

结果：LongAdder性能明显优于AtomicLong

原理：（1）AtomicLong:每次自增完成后，都要由自增的线程将运行的结果从工作内存刷新到主内存，其他线程再从主内存加载到线程的工作内存运行下一次的累加操作

（2）LongAdder:每个线程都有一个自己的计数器，不会每次做完累加都将结果进行同步，本质上是通过空间换取时间。

sum源码：当并发不激烈的时候直接将结果加在base上;当并发激烈时，将累加放在Cell[]

中,数组中一个元素对应一个线程。最后将Cell[]和base相加得到最终结果。

存在的问题:在做sum时可能cell[]中的一个元素被加后又被修改，导致最后sum的结果不准确。

    public long sum() {
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

7、CAS的定义

Compare and swap,比较交换，逻辑：我认为V的值应该是A，如果是A则认为它没有被修改过，则将其置为B，如果不是A则修改失败。其中V为内存的值，A为预期值，B为要修改的值。

 整个比较和赋值的操作是一个原子操作不会出现并发问题

do while循环保证修改能完成，compareAndSwapInt保证操作是原子的

 

 （3）AtomicInteger的compareAndSet方法

最后调用的是unsafe中的native方法 compareAndSwapInt(对象，属性在类中的偏移量，预期值，要修改的值)

 9、Unsafe类

Java无法直接访问底层的操作系统，unsafe相当于是一个后门能够提供硬件级别的原子操作。

Unsafe.objectFieldOffset()获取对象中字段的偏移量，以便能够直接获取对象的字段在内存中的值。

 10、CAS的缺点

（1）ABA问题:检查时不能正真正的检查到是否数值被修改，如果是将A改为了B再改回A

会认为没被修改过。解决方案加版本号。

（2）当竞争激烈时，会一直自旋使CPU效率降低

11、自己利用unsafe实现自旋锁

package atomicandcas;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

public class CasDemo implements Runnable{
    public volatile int value;
    private static final Unsafe unsafe;
    private static final long offset;
    static {
        try {
            //通过反射获取Unsafe对象
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe= (Unsafe)field.get(null);
            offset=unsafe.objectFieldOffset(CasDemo.class.getField("value"));
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw  new Error(e);
        }
    }

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

    @Override
    public void run() {
        int v=0;
        do{
            v=unsafe.getIntVolatile(this,offset);
            System.out.println(Thread.currentThread().getName()+"正在自旋");
        }while (!unsafe.compareAndSwapInt(this,offset,v,v+1));
        System.out.println(Thread.currentThread().getName()+"完成累加，当前值："+value);
    }

    public static void main(String[] args) throws InterruptedException {
        CasDemo casDemo=new CasDemo(0);
        for (int i = 0; i <10 ; i++) {
            new Thread(casDemo).start();
        }
        Thread.sleep(1000);
        System.out.println("运行结果:"+casDemo.value);
    }

}

运行结果：

 说明：

（1）private static final Unsafe unsafe = Unsafe.getUnsafe();会报错，源码如下，自己编写的类时不能调用getUnsafe()方法的，所以我们用反射的方法方式来获取Unsafe对象。

（2）通过cas加自旋的方式来实现乐观锁，保证了并发情况下累加不会出错。