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