Java中关于atomic的理解及使用示例

atomic对于数据原子性操作较方便处理，即当多个线程对同一个变量进行更新时，仅有一个线程可以成功，而未能成功的形成会像自旋锁一样，继续尝试，一直等到执行成功。

原子性原理：

 

 一、i++的原子性,i++的操作，分为三部分："读-改-写"

            int i = 10;

            i = i++; //10

       

            int temp = i;

            i = i + 1;

            i = temp;

       

 二、原子变量：java.util.concurrent.atomic包下提供了常用的原子变量

           1.volatile 保证内存可见性

           2.CAS（Compare-And-Swap）算法保证数据的原子性

             CAS算法是硬件对于并发操作共享数据的支持。

             CAS包含了三个操作数：

                内存值：V

                预估值：A

                更新值：B

                当且仅当V == A， V = B，否则，不做任何操作。

嗯~~~理解以及使用直接上代码………………

import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntUnaryOperator;
import static java.lang.Float.*;

public class AtomicPrac {
    public static void main(String[] args) {
        AtomicDemo atomicDemo = new AtomicDemo();
        atomicDemo.setNumberA(new AtomicInteger(3));
        for (int i = 1; i <= 10; i++) {
            new Thread(atomicDemo).start();
        }
        
        AtomicInteger j=new AtomicInteger(4);
        System.out.println(j.incrementAndGet());
        System.out.println(updateAndGetInt(j,p -> p/2 ));
        
        //double型数据
        AtomicFloat k = new AtomicFloat(5);
        System.out.println(updateAndGetDouble(k,p -> p/2 ));
        
    }
    //模拟底层实现：
    public static float updateAndGetDouble(AtomicFloat i, DoubleUnaryOperator operator){
        while(true){
            float prev=i.get();//得到当前值
            float next=(float) operator.applyAsDouble(prev);//将旧值传入，让接口的某个方法完成具体运算，返回计算结果
            //重写compareAndSet
            if(i.compareAndSet(prev,next)){
                return next;
            }
        }
    }
    public static int updateAndGetInt(AtomicInteger i, IntUnaryOperator operator){
        while(true){
            int prev=i.get();//得到当前值
            int next=operator.applyAsInt(prev);//将旧值传入，让接口的某个方法完成具体运算，返回计算结果
            if(i.compareAndSet(prev,next)){
                return next;
            }
        }
    }
    //模拟底层实现：
}
class AtomicDemo implements Runnable {
    public AtomicInteger numberA;
    
    public void run() {
        try {
              Thread.sleep(200);
        } catch (InterruptedException e) {
              e.printStackTrace();
        }
          System.out.println(Thread.currentThread().getName() + ":" + getNumberA());
    }

    public int getNumberA() {
        return numberA.updateAndGet(x -> x*2);
    }

    public void setNumberA(AtomicInteger numberA) {
        this.numberA = numberA;
    }
}

//对于使用双精度型的数据对应AtomicLong 自定义AtomicDouble   转换doubleToLongBits(1.00);
//对于使用单精度型的数据对应AtomicInteger 自定义AtomicFloat   转换floatToIntBits(1.00);
class AtomicFloat extends Number {
    
    private AtomicInteger bits;
    
    public AtomicFloat() {
        this(0f);
    }
    
    public AtomicFloat(float initialValue) {
        bits = new AtomicInteger(floatToIntBits(initialValue));
    }
    
    public final boolean compareAndSet(float expect, float update) {
        return bits.compareAndSet(floatToIntBits(expect),
                floatToIntBits(update));
    }
    
    public final void set(float newValue) {
        bits.set(floatToIntBits(newValue));
    }
    
    public final float get() {
        return intBitsToFloat(bits.get());
    }
    
    public float floatValue() {
        return get();
    }
    
    public final float getAndSet(float newValue) {
        return intBitsToFloat(bits.getAndSet(floatToIntBits(newValue)));
    }
    
    public final boolean weakCompareAndSet(float expect, float update) {
        return bits.weakCompareAndSet(floatToIntBits(expect),
                floatToIntBits(update));
    }
    
    public double doubleValue() { return (double) floatValue(); }
    public int intValue()       { return (int) get();           }
    public long longValue()     { return (long) get();          }
}

运行结果：

5
2
2.5
Thread-0:6
Thread-1:12
Thread-4:24
Thread-9:192
Thread-8:384
Thread-3:768
Thread-2:96
Thread-5:48
Thread-6:3072
Thread-7:1536