JUC之Atomic

这个是在学习工作中的一些总结，若有不对之处欢迎大家指出。侵删！
需要源码联系QQ:1352057131
得之在俄顷，积之在平日。

原子类的作用

原子类和锁的作用类似，都是为了保证并发情况下的线程安全，不过原子类相比于锁有一定的优势：

粒度更细：原子变量可以把竞争范围缩小到变量级别。
效率更高：使用原子类的效率比使用锁的效率更高，但是高竞争下的情况除外。

原子类概览

Atomic*基本类型原子类

AtomicInteger常用方法

//获取当前的值并加上预期的值
atomicInteger.getAndAdd(int value);
//获取当前值
atomicInteger.get();
//获取当前值并自减
atomicInteger.getAndDecrement();
//获取当前值并自增
atomicInteger.getAndIncrement();
//获取当前值并设置新值
atomicInteger.getAndSet(int value);
//如果输入的值等于预期值，则以原子的方式将该值设置为输入值（update）
atomicInteger.compareAndSet(int value,int update);

AtomicInteger示例

public class AtomicTest implements Runnable{
    private static  AtomicInteger atomicInteger = new AtomicInteger(0);
    private static int a = 0;
    public static void Atomicadd(){
        atomicInteger.getAndIncrement();
    }
    public static void add(){
        a++;
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread0 = new Thread(new AtomicTest());
        Thread thread1 = new Thread(new AtomicTest());
        thread0.start();
        thread1.start();
        thread0.join();
        thread1.join();
        System.out.println("atomicInteger="+atomicInteger);
        System.out.println("a="+a);
    }
    @Override
    public void run() {
        for (int i = 0; i <100000 ; i++) {
            Atomicadd();
            add();
        }
    }
}

运行结果：

从图中可以看出AtomicInteger是线程安全的

Atomic*Array数组类型原子类

AtomicIntegerArray示例

public class AtomicTest{
    //声明长度为100的AtomicIntegerArray
    private static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(100);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.submit(new Add(atomicIntegerArray));
        executorService.submit(new Dec(atomicIntegerArray));
        Thread.sleep(1000);
        executorService.shutdown();
        for (int i = 0; i <atomicIntegerArray.length() ; i++) {

            if (atomicIntegerArray.get(i)!=0){
                System.out.println("发现不等于0的数");
            }
        }
        System.out.println("执行完毕");
    }
}
class Add implements Runnable{
    private AtomicIntegerArray atomicIntegerArray;

    public Add(AtomicIntegerArray atomicIntegerArray) {
        this.atomicIntegerArray = atomicIntegerArray;
    }
    @Override
    public void run() {
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            //加1
            atomicIntegerArray.getAndIncrement(i);
        }
    }
}
class Dec implements Runnable{
    private AtomicIntegerArray atomicIntegerArray;

    public Dec(AtomicIntegerArray atomicIntegerArray) {
        this.atomicIntegerArray = atomicIntegerArray;
    }
    @Override
    public void run() {
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            //减1
            atomicIntegerArray.getAndDecrement(i);
        }
    }
}

Atomic*Reference引用类型原子类

AtomicReference示例

Atomic*FieldUpdater升级类型原子类

AtomicIntegerFieldUpdater示例

public class AtomicIntegerFieldUpdaterTest implements Runnable{
    //第一个参数为类  第二个参数为要升级的变量名
    AtomicIntegerFieldUpdater<User> aifu = AtomicIntegerFieldUpdater.newUpdater(User.class,"number");
    static User tom = new User();
    static User tony = new User();
    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerFieldUpdaterTest aifut = new AtomicIntegerFieldUpdaterTest();
               for (int i = 0; i < 1000; i++) {
            Thread thread0 = new Thread(aifut);
            Thread thread1 = new Thread(aifut);
            thread0.start();
            thread1.start();
            thread0.join();
            thread1.join();
        }
        System.out.println("tom"+tom.number);
        System.out.println("tony"+tony.number);
    }
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            tom.number++;
            aifu.getAndDecrement(tony);
        }
    }
    static class User{
        volatile int number;//分数
    }
}

Adder累加器

为什么要使用Adder

高并发下LongAdder比AtomicLong效率高，不过本质是空间换时间。
竞争激烈的时候，LongAdder把不同的线程对应到不同的Cell上进行修改,降低了冲突的概率，事多段锁的理念，提高了并发性。

LongAdder示例

public class AdderTest implements Runnable{
    private static LongAdder longAdder = new LongAdder();
    public void Adder_Add(){
        longAdder.increment();
    }
    @Override
    public void run() {
        Adder_Add();
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i <10000 ; i++) {
            executorService.submit(new AdderTest());
        }
        executorService.shutdown();
        while (!executorService.isTerminated()){
        }
        System.out.println(longAdder);
    }

LongAdder与AtomicLong性能对比
LongAdder：

```java
public class AdderTest implements Runnable{
    private static LongAdder longAdder = new LongAdder();
    public void Adder_Add(){
        for (int i = 0; i < 1000; i++) {
            longAdder.increment();
        }
    }
    @Override
    public void run() {
        Adder_Add();
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i <100000 ; i++) {
            executorService.submit(new AdderTest());
        }
        executorService.shutdown();
        while (!executorService.isTerminated()){
        }
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));
    }
}

AtomicLong：

public class AtomicLongTest implements Runnable{
    private static AtomicLong atomicLong = new AtomicLong(0);
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            atomicLong.getAndIncrement();
        }
    }
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i <100000 ; i++) {
            executorService.submit(new AtomicLongTest());
        }
        executorService.shutdown();
        while (!executorService.isTerminated()){
        }
        long end = System.currentTimeMillis();
        System.out.println("执行时间："+(end-start));
    }
}

从运行结果可以看出LongAdder的效率明显要高很多，原因如下：
AtomicLong每次加法都要flush和refresh导致很耗费资源

从图中可以看出AtomicLong每次加法都要做同步，在高并发的情况下会导致冲突比较多因此效率下降，而LongAdder每个线程都会有自己的计数器，仅用来在自己线程内计数，这样就不会受到其他线程计数器的干扰。如下图



从图中可以看出，第一个线程的计数器数值，也就是str’，为1的时候，可能线程2的计数器ctr”的数值已经是3了，他们之间并不存在竞争关系，所以在加和的过程中根本不需要同步机制，也不需要flush和refresh。也没有公共的counter来计数。只是到最后sum的时候才会同步将所有的数值累加起来 。
适用场景

适用于统计求和计数的场景，而且LongAdder基本只提供了add方法，AtomicLong还具有cas操作。