Java原子更新基本类型

当程序更新一个变量时,如果是多线程同时更新这个变量,可能得到期望之外的值,比如变量i=1,A线程更新i+1,B线程也更新i+1,经过两个线程操作之后可能i不等于3,而是等于2。因为A、B线程在更新i时拿到的i都是1,这就是线程的不安全更新操作,通常我们会使用Synchronized来解决这个问题(也可以通过加锁的方式 ),synchronized(或加锁)会保证多线程不会同时更新变量i。

而在JDK的java.util.concurrent.atomic包中的原子类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。

因为类型有很多种,所以在Atomic包中提供了13个类,4种类型的原子更新方式,分别是原子更新基本类型,原子更新数组,原子更新引用和原子更新属性(字段)。Atomic中的类基本都是使用Unsafe实现的包装类

原子更新基本类型

使用原子的方式更新基本类型,Atomic包提供了以下三个类。

AtomicBoolean:原子更新布尔类型。

AtomicInteger原子更新整型。

AtomicLong原子更新长整型。

这三个类提供的方法基本一样,下面以AtomicInteger来讲解,AtomicInteger的常用方法如下。

getAndAdd


/**
     * Atomically adds the given value to the current value.
     *
     * @param delta the value to add
     * @return the previous value
     */
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

 

compareAndSet

   
/**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

 

getAndIncrement 以原子方式将当前值加1,注意,这里返回的是自增前的值

  
/**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

 

getAndSet 返回的是旧值(细心留意方法名可以发现,get在前面是获取旧值再操作,Get在后面是获取操作后的新值)

 
/**
     * Atomically sets to the given value and returns the old value.
     *
     * @param newValue the new value
     * @return the previous value
     */
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

 

示例


/**
 * @author perist
 * @date 2017/3/19
 * @time 22:56
 */
public class AtomicIntegerTest {
static AtomicInteger atomicInteger = new AtomicInteger(1);

public static void main(String[] args) {

    System.out.println(atomicInteger.getAndIncrement());
    System.out.println(atomicInteger.get());
}

}

该示例输出


1
2

Process finished with exit code 0

 

那么getAndIncrement 是如何实现原子操作的呢,?我们分析下其源码:

unsafe.getAndAddInt(this, valueOffset, 1);
 
public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    return var5;
}

关键是调用compareAndSwapInt,该方法先检查当前数值是否等于var5,等于意味着AtomicInteger没有被其他线程修改过,则将AtomicInteger的当前值更新为var5+var4,如果不等于compareAndSwapInt返回false,程序会进入do...while重新进入操作

Atomic包提供了3种基本类型的原子更新,但是Java的基本类型还有char,float,double等。那么问题来了如何更新其他的基本类型呢,?atomic包里的类基本都是Unsafe实现的,让我们看一下Unsafe源码:


public final native boolean compareAndSwapInt(Object o,
 long offset,
 int expected, 
 int x);
public final native boolean compareAndSwapLong(Object o,
 long offset,
 long expected,
 long x);
public final native boolean compareAndSwapObject(Object o,
 long offset,
 Object expected,
 Object x);

 

通过源码,我们发现Unsafe只提供了3种CAS操作,再看AtomicBoolean源码,发现它也是先把Boolean转换成整型,再使用compareAndSwapInt进行CAS操作的,所以原子更新char,float,double也可以用类似的思路来解决。

 

 

# java 

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×