多线程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 2	1 2比较 false 2 3 比较false 3

这样就实现了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;
}