AtomicInteger 소스 코드 학습

먼저 AtomicInteger 클래스 의 설명 을 보십시오. '... An AtomicInteger is used in applications such as atomically incremented counters, and can not be replacement for an Integer. However, this class does extend Number to allow uniform access by tools and utilities that deal with numercally - based classes.' AtomicInteger 자체 속성 및 정적 코드 블록 과AtomicBoolean 기본적으로 똑 같 습 니 다. 여 기 는 간단하게 붙 일 뿐 입 니 다.

private static final Unsafe unsafe = Unsafe.getUnssafe();
private static final long offsetValue;
static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField('value'));
    }catch(Exception e){throw new Error(e);}
}
private volatile int value;

자, 이어서 몇 가지 방법 을 말 해 보 세 요.

/**     */
public final void set(int newValue){value = newValue;}
/**
*Eventually sets the given value
*     1.6  
*/
public final void lazySet(int newValue){
    unsafe.putOrderInt(this,valueOffset,newValue);
}
/**
*Atomically sets to the given value and returns the old
* value.
*         ，     
*/
public final int getAndSet(int newValue){
    return unsafe.getAndSetInt(this,valueOffset,newValue);
}
/**
*Atomically sets the value to the given updated value
*if the current value == the expect value
*     (valueOffset       )      (expect)，
*      update     
*@return         true,    false
*/
public fianl boolean compareAndSet(int expect,int update){
    return unsafe.compareAndSwapInt(this,valueOffset,
                                        expect,update);
} 

위의 방법 은 현재 값 을 주어진 값 으로 수정 하 는 것 입 니 다. 다음은 다른 그룹 이 일정한 증분 에 따라 현재 값 을 증가 (감소) 하 는 것 을 보 겠 습 니 다.

/**
*Atomically increments by one the current value
*        1
*    
*/
public fianl int getAndIncrement(){
    return unsafe.getAndAddInt(this,valueOffset,1);
}
/**
*   getAndIncrement  ，           
*/
public final int incrementAndGet(){
    return unsafe.getAndAddInt(this,valueOffset,1)+1;
}
/**
*       1
*    
*/
public final int getAndDecrement(){
    return unsafe.getAndAddInt(this,valueOffset,-1);
}
/**
*       1
*    
*/
public final int decrementAndGet(){
    return unsafe.getAndAddInt(this,valueOffset,-1)-1;
}
/**
*          
*    
*/
public final int getAndAdd(int delta){
    return unsafe.getAndAddInt(this,valueOffset delta);
}
/**
*          
*    
*/
public final int addAndGet(int delta){
    return unsafe.getAndAddInt(this,valueOffset delta)
                                        +delta;
}

1 조 1, 8 에 추 가 된 몇 가지 방법 을 살 펴 보 겠 습 니 다.

/**
*Atomically updates the current value with the resuls
* of applying the given function,returning thre previous
* value,...it may be  re-applied when attempted udates
* fail due to contention among threads.
*  the given function          ，     
*        。
*    
*/
public final int getAndUpdate(IntUnaryOperator
                                updateFunction){
    int prev,next;
    do{
        prev = get();
        next = updateFunction.applyAsInt(prev);
    }while(!compareAndSet(prev,next));
    return prev;
}
        updateAndGet，           。
/**
*...The function is applied with the current value as its
*first argument,and the given update as the second 
*argument.
*
*    
*/
public final int getAndAccumulate(int x,
                IntBinaryOperator accumulateFunction){
    int prev,next;
    do{
        prev = get();
        next = accumulateFunction.applyAsInt(prev,x);
    }while(!compareAndSet(prev,next));
    return prev;
}
         accumulateAndGet,           

getAndUpdate 와 getAndAccumulate 에 대한 두 가지 예:

@Test
public void testGetAndUpdate(){
    AtomicInteger atomicInteger = new AtomicInteger(1);
    //x    1，         x+3
    IntUnaryOperator function = x -> x + 3;
    int prev = atomicInteger.getAndUpdate(function);
    System.out.println("prev:"+prev+",next:"+
    atomicInteger.get());
    //     prev:1,next:4
}

@Test
public void testAccumulateAndGet(){
    AtomicInteger atomicInteger = new AtomicInteger(1);
    int updateValue = 2;
    //x    1，y updateValue   2，         x+y
    IntBinaryOperator function = (x,y)->x+y;
    int prev = atomicInteger.accumulateAndGet(updateValue,
                                    function);
    System.out.println("prev:"+prev+",next:"+
                            atomicInteger.get());
    //     prev:1,next:3
}

getAndUpdate 와 accumulate AndGet 은 각각 1 원 인터페이스 인 IntUnary Operator 와 2 원 인터페이스 인 IntBinary Operator 의 구체 적 인 실현 에 의존 하고 있 으 며, 수정 전의 값 을 되 돌려 주 는 것 이 며, updateAndGet 과 getAndAccumulate 는 수 정 된 값 을 되 돌려 주 는 것 으로 나 타 났 다. Number 에 재 작성 하 는 몇 가지 방법 은 말 할 것 도 없 이 get 방법 을 사용 했다.