Java并发之AtomicInteger详解-优快云博客

本文链接：https://blog.youkuaiyun.com/venus321/article/details/78764604

java.util.concurrent.atomic介绍

在这个包下，主要提供了一些对于更新单个变量、引用字段，数组元素对象的原子操作。

回顾一个操作

对于i++和++i对于大家，可谓在熟悉不过了。

            int i = 0;
            //i++;
            //System.out.println(i);//正确是1，这个比较容易出错，有人可能说怎么不是0，不是先进行赋值，应该是0呀，注意你看这里并没有赋值，还是针对i本身的呀。比较后面int a =i++;你就知道了
            //++i;
            //System.out.println(i);//正确是1
            //int a =i++;
            //System.out.println(a+"   "+i);//  a 0 i 1

             int c = ++i;
             System.out.println(c+"    "+i);// c 1   i 1

问题引出

回顾了基本自增操作，我们来看看这个操作在多线程中操作。

  public static void main(String[] args) {
        MyTask9 m9 = new MyTask9();
        Thread t = new Thread(m9);
        Thread t1 = new Thread(m9);
        t.start();
        t1.start();

    }
}

    class MyTask9 implements Runnable{
        int i = 0;
        @Override
        public void run() {
            // TODO Auto-generated method stub
            //synchronized (new MyTask9()) {
                i++;
                System.out.println(i);

            //}



        }

对于上面的一段代码，我们最希望看到的就是最后的结果应该是1 2，但是发现结果还出现 2 2。

自增这里面有三个独立的操作：获得变量当前值，为该值+1/-1，然后写回新的值。只能使用加锁才能保证读-改-写这三个操作是“原子性”的。（参考:https://www.cnblogs.com/timlearn/p/4127616.html）同步问题，我们之前讲过，这里，就不重点说了。我们是否可以不加锁的情况下，避免下面的问题。

AtomicInteger

常用方法

下面的方法都是基于原子操作，保证原子性。


            AtomicInteger()创建具有初始值 0 的新 AtomicInteger。

            AtomicInteger(int initialValue)创建具有给定初始值的新 AtomicInteger。
            a.getAndIncrement();//类似i++;
            a.decrementAndGet();//类似--i;
            a.getAndDecrement();//类似i--;
            a.incrementAndGet();//类似++i;
            a.getAndSet();//返回旧值，

在上述代码中，做如下改动，你就发现上面的问题已经避免了。

AtomicInteger a = new AtomicInteger();
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(a.incrementAndGet());
        }

看到这里的你，一定疑惑，为啥，不采用锁机制，也能处理了。其实，它这个方法是通过乐观锁（cas）+volatile

悲观锁乐观锁

悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。再比如Java里面的同步原语synchronized关键字的实现也是悲观锁。（这里面也告诉我们，使用锁的一种缺陷就是会导致其他的线程无故挂起）

乐观锁：顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

CAS （了解一下）

上面提到的乐观锁的概念中其实已经阐述了它的具体实现细节：主要就是两个步骤：冲突检测和数据更新。其实现方式有一种比较典型的就是 Compare and Swap ( CAS )。

CAS是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。　　　

CAS 操作中包含三个操作数 —— 需要读写的内存位置（V）、进行比较的预期原值（A）和拟写入的新值(B)。如果内存位置V的值与预期原值A相匹配，那么处理器会自动将该位置值更新为新值B。否则处理器不做任何操作。

参考:https://www.cnblogs.com/qjjazry/p/6581568.html

源码分析

看getAndIncrement如何在没有锁的情况下，实现i++的原子一致性。

 /**
  155        * Atomically increments by one the current value.
  156        *
  157        * @return the previous value
  158        */
  159       public final int getAndIncrement() {
  160           for (;;) {
  161               int current = get();
  162               int next = current + 1;
  163               if (compareAndSet(current, next))
  164                   return current;
  165           }
  166       }

compareAndSet这个方法会通过比较期望值和当前值比较，如果一直则返回当前值。在这里为了保证字段的修改后的可见性，它使用volatile 关键字。compareAndSet底层如何实现，大家有兴趣可以了解。

CAS 问题（了解）

CAS看起来很爽，但是会导致“ABA问题”。

CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，但是在这个时间差内任何变化都可能发生。

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成了B，然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。如果链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。要解决”ABA问题”，我们需要增加一个版本号，在更新变量值的时候不应该只更新一个变量值，而应该更新两个值，分别是变量值和版本号

AtomicIntegerArray

该类主要提供了对数组元素的原子操作的方法。

AtomicIntegerArray aa  =  new AtomicIntegerArray(6);
       aa.set(0, 77);
       aa.set(1,22);
       System.out.println(aa.get(0));
       System.out.println(aa.get(1));
       int[] a = new int[]{1,2,3,4,5};
       AtomicIntegerArray aa1  =  new AtomicIntegerArray(a);
       aa1.set(0, 520);
        System.out.println(a[0]);
    }

AtomicIntegerArray类需要注意的是，数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响到传入的数组。

AtomicReference

该类主要提供对引用类型对象的更新。

AtomicReference<User> a = new AtomicReference<User>(new User());
       User u = new User();
       u.setAge(23);
       a.set(u);
       System.out.println(u.getAge());

AtomicIntegerFieldUpdater

该类提供对Integer字段的修改，是基于反射的。动态加载需要需修改的字段。

 AtomicIntegerFieldUpdater<User> as = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");
       //AtomicIntegerFieldUpdater是一个抽象类，通过静态方法去构造一个更改器，然后通
       //过反射动态加载要走修改字段的类，并且指明修改字段名
       User u = new User();
       as.getAndSet(u,23);
       System.out.println(as.get(u));
       //需要注意的是AtomicIntegerFieldUpdater中所有可用的方法，
       //都是针对更改器这个对象的这个字段，比如这里打印user，按之前应该
       //打印所有字段的值，而现在只是age

在要修改的字段，一定必须要 public volatile 修饰，否则报错，原因很简单，没有public 其他的类不能访问，没有volatile，可见性保证不了

参考： http://ifeve.com/java-atomic/

原子类并不一定完全安全

package com.example.test;

import java.util.concurrent.atomic.AtomicInteger;

public class Test201 implements Runnable {
    AtomicInteger a = new AtomicInteger(0);

    public void addNum(){
        System.out.println("加了100      "+a.addAndGet(100));
        System.out.println("加了1     "+a.addAndGet(1));
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        addNum();

    }   
}

package com.example.test;

public class Test202 {
    public static void main(String[] args) {
        Test201 t = new Test201();
        Thread[] tt = new Thread[10];
        for(int i = 0;i<10;i++) {
            tt[i] = new Thread(t);
            tt[i].start();
        }
    }
}