多线程atomicInteger

并发编程的3个重要概念

1.原子性：

一个操作或者多个操作，要么全部成功，要么全部失败

1.java中保证了基本数据类型的读取和赋值,保证了原子性,这些操作不可终端

a=10  原子性

b=a    不满足 1.read a; 2.assign b;

c++    不满足  1.read c; 2 add 3.assige to c

c=c+1  不满足 1.read c 2.add; 3. assign to c;

2.可见性：

volatile 可以保证可见性.主要是把变量放在主存里

多个线程访问这个变量，一个线程修改之后必须保证另一个线程可以看见。

每一个线程都自己的缓存，有的变量在主存区，我们要保证变量的可见性

4.顺序性：

java中hapens-before 原则保证了有序性

4.1 代码顺序(程序顺序规则): 单个线程中的每个操作编写在前面的反生在编写在后面的

4.2 lock原则(监视器锁规则) : unlock 必须发生在lock之后

4.3 volatile变量规则: 对该变量的写操作必须发生在读操作之前.就是一个变量写变量发生在读变量之前

4.4 传递规则: a->b->c 那么a肯定在c之前

4.5 start规则: 先start 线程在启动(个人认为废话)

4.6 中断规则: 对线程的中断先发生在捕获interpetor异常之前(个人认为废话)

4.7 对象的销毁规则: 一个对象的初始化.必须发生在finalize 之前(个人认为废话)

4.8 线程的终结规则: 所有操作都发生在线程死亡之前 (个人认为废话)

比如定义一个变量

int i =0;

boolean flag =false;

int i =1;

boolean flag =true;

java中有重排序的过程 因为这几条代码没有关联性可能会变成

int i =0;

boolean flag =false;

boolean flag =true;

int i =1;

重排序只保证最终一致性，重排序也是有依赖关系的，重排序对没有依赖关系的可以重排序，重排序不会影响单线程，但是会影响多线程

举个例子

--------thread-1 ==========

obj =createObj();1

flag = true; 2

如果这里发生指令重排将  1 -2 顺序颠倒下面下面的代码就会报出空指针异常

-----thread-2------
while(!flag){
}
useObject()

atomic 具有原子性

主要有俩点 1.他的变量是volatile

　　　　　 2.unsafe方法调用

    // setup to use Unsafe.compareAndSwapInt for updates

    private static final Unsafe unsafe = Unsafe.getUnsafe();

    private static final long valueOffset;

    static {

        try {

            valueOffset = unsafe.objectFieldOffset

                (AtomicInteger.class.getDeclaredField("value"));

        } catch (Exception ex) { throw new Error(ex); }

    }

    private volatile int value;

什么时候需要使用atomic类对象

当多线程操作一个变量的时候。如果使用传统的变量会出错，很多同学为了解决这个问题，加了votatile修饰。也并不能够解决问题。

补充下votalite 的知识

volatile具有可见性、有序性，不具备原子性。

当value+=1时候我们需要做几个操作

1.从主存区获取变量到写存区

2.value+1

3.value = 新的value

4.讲变量写入主存区　

这4步都是原子性的。但是在多线程环境中。可能你读取到的变量是别人修改过的变量造成线程不安全情况　　

  private static Set<Integer> set = Collections.synchronizedSet(new HashSet<>());

    public static void main(String[] args) throws InterruptedException {

       Thread t1= new Thread(()->{

            int x=0;

            while (x<500){

                set.add(value);

                int temp =value;

                System.out.println(Thread.currentThread().getName()+"   "+temp);

                value +=1;

                x++;

            }

        });

        Thread t2= new Thread(()->{

            int x=0;

            while (x<500){

                set.add(value);

                int temp =value;

                System.out.println(Thread.currentThread().getName()+"   "+temp);

                value +=1;

                x++;

            }

        });

        Thread t3= new Thread(()->{

            int x=0;

            while (x<500){

                set.add(value);

                int temp =value;

                System.out.println(Thread.currentThread().getName()+"   "+temp);

                value +=1;

                x++;

            }

        });

        t1.start();

        t2.start();

        t3.start();

       t1.join();

        t2.join();

        t3.join();

        System.out.println(set.size());

」

当我们使用aomic类时。可以保证原子性

     AtomicInteger atoValue = new AtomicInteger();

        Thread t1= new Thread(()->{

            int x=0;

            while (x<500){

                int i = atoValue.getAndIncrement();

                set.add(i);

                System.out.println(Thread.currentThread().getName()+"   "+i);

                atoValue.getAndIncrement();

                x++;

            }

        });

        Thread t3= new Thread(()->{

            int x=0;

            while (x<500){

                int i =atoValue.getAndIncrement();

                set.add(i);

                System.out.println(Thread.currentThread().getName()+"   "+i);

                atoValue.getAndIncrement();

                x++;

            }

        });

        Thread t2= new Thread(()->{

            int x=0;

            while (x<500){

                int i = atoValue.getAndIncrement();

                set.add(i);

                System.out.println(Thread.currentThread().getName()+"   "+i);

                x++;

            }

        });

        t1.start();

        t2.start();

        t3.start();

        t1.join();

        t2.join();

        t3.join();

        System.out.println(set.size());

下载jdk源码

http://download.java.net/openjdk/jdk8/promoted/b132/openjdk-8-src-b132-03_mar_2014.zip

源码查看

/openjdk/jdk/src/share/classes/sun/misc/Unsafe.java

atomic保证原子性操作是因为有unsafe.java

很多人都说unsafe.java 是java留的一后门可以直接操作cpu级别的内存

因为UnSafe提供了硬件级别的原子操作，提高了Java对底层操作的能力。Unsafe类使Java语言拥有了像C语言的指针一样的操作内存空间的能力

一篇比较好的博客

https://www.cnblogs.com/pkufork/p/java_unsafe.html

如何保证原子性

/**

     * Atomically adds the given value to the current value of a field

     * or array element within the given object <code>o</code>

     * at the given <code>offset</code>.

     *

     * @param o object/array to update the field/element in

     * @param offset field/element offset

     * @param delta the value to add

     * @return the previous value

     * @since 1.8

     */

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

　　1、需要修改的对象
  2、更改属性的内存偏移量 

  4、要添加的 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;
 }

其实主要原子性是通过compareAndSwapInt对比算法.传入你开始的值.和预期的值 如果不相同就一直执行下去直到相同为止,达到很多人说的无锁概念,其实我更倾向于自旋锁
假设多线程调用getAndIncrement  
假设初始值是1

compareAndWapInt(1,1+1)

compareAndWapInt(1,1+1)

1 2 比较false

进行下一次 2==2

1 2比较 false

2 3 比较false

这样就实现了free lock

获取unsafe.实例利用java反射

   Field f = Unsafe.class.getDeclaredField("theUnsafe");

         f.setAccessible(true);

         Unsafe unsafe = (Unsafe) f.get(null);

自己测试类

  public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {

         Field f1 = Unsafe.class.getDeclaredField("theUnsafe");

         f1.setAccessible(true);

         Unsafe unsafe = (Unsafe) f1.get(null);

        Class clazz = Target.class;

        Field[] fields = clazz.getDeclaredFields();

        for (Field f : fields) {

            // 获取属性偏移量，可以通过这个偏移量给属性设置

            System.out.println(f.getName() + ":" + unsafe.objectFieldOffset(f));

        }

        Target target = new Target();

        Field intFiled  =  clazz.getDeclaredField("intParam")  ;

//        int a=(Integer)intFiled.get(target ) ;

//        System.out.println("原始值是:"+a);

        //intParam的字段偏移是12 原始值是3 我们要改为10

        System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10));

        int b=(Integer)intFiled.get(target) ;

        System.out.println("改变之后的值是:"+b);

//

//        //这个时候已经改为10了,所以会返回false

        System.out.println(unsafe.compareAndSwapInt(target, 12, 3, 10));

//

//        System.out.println(unsafe.compareAndSwapObject(target, 24, null, "5"));

    }

}

class Target {

    int intParam=3;

    long longParam;

    String strParam;

    String strParam2;

}