package TestAtomicInteger;
import java.util.concurrent.atomic.AtomicInteger;
class MyThread implements Runnable {
// static int i = 0;
static AtomicInteger ai=new AtomicInteger(0);
public void run() {
for (int m = 0; m < 1000000; m++) {
ai.getAndIncrement();
}
}
};
public class TestAtomicInteger {
public static void main(String[] args) throws InterruptedException {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
Thread t2 = new Thread(mt);
t1.start();
t2.start();
Thread.sleep(500);
System.out.println(MyThread.ai.get());
}
}
可以发现结果都是2000000,也就是说AtomicInteger是线程安全的。
这里,我们来看看AtomicInteger是如何使用非阻塞算法来实现并发控制的。
AtomicInteger的关键域只有一下3个:
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
private volatile int value;
这里, unsafe是java提供的获得对对象内存地址访问的类,注释已经清楚的写出了,它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。
valueOffset是用来记录value本身在内存的编译地址的,这个记录,也主要是为了在更新操作在内存中找到value的位置,方便比较。
注意:value是用来存储整数的时间变量,这里被声明为volatile,就是为了保证在更新操作时,当前线程可以拿到value最新的值(并发环境下,value可能已经被其他线程更新了)。
这里,我们以自增的代码为例,可以看到这个并发控制的核心算法:
public class AtomicInteger extends Number implements java.io.Serializable {
......
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
private volatile int value;
......
......
/**
* Gets the current value.
*
* @return the current value
*/
public final int get() {
return value;
}
......
/**
* Atomically increments by one the current value.
* @return the updated value
*/
public final int incrementAndGet() {
// 一直循环的目的是为了“预期值”与“真实值”不一致的情况下,
// 能够重新进行+1计算
for (;;) {
// 取得/重新取得 当前的value值
int current = get();
// 将当前值+1
int next = current + 1;
/**
这是最关键的,使用JDK中实现的CAS机制
对当前值和预期值进行比较
如果当前值和预期的(CAS算法需要你额外给出一个期望值,也就是你认为现在的变量应该是什么样子的,如果变量
不是你想象的那样,那就说明已经被别的线程修改过了,你就需要重新读取,再次尝试修改即可)不一样,
说明有某一个其他线程完成了值的更改那么进行下一次循环,进行重新操作(因为之前的操作结果就不对了)
循环的内容是
1.取得当前值
2.计算+1后的值
3.如果当前值没有被覆盖的话,设置那个+1后的值
4.如果设置失败(如:线程A取出当前值为1 按理说预期要修改的值也为1 但在此之前线程B已经执行过+1操作
结果期望值已经变成了2 1!=2 所以失败 ),
再从1开始(此时如果没有其他线程修改该变量的话,那么当前值是2 期望值是2) 计算成功
CAS的全称是Compare And Swap 即比较交换,其算法核心思想如下
执行函数:CAS(V,E,N)
其包含3个参数
V表示要更新的变量
E表示预期值
N表示新值
如果V值等于E值,则将V的值设为N。若V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做。通俗的理解就是CAS操作需要我们提供一个期望值,当期望值与当前线程的变量值相同时,说明还没线程修改该值,当前线程可以进行修改,也就是执行CAS操作,但如果期望值与当前线程不符,则说明该值已被其他线程修改,此时不执行更新操作,但可以选择重新读取该变量再尝试再次修改该变量,也可以放弃操作
*/
//已知当前内存里面的值current(即期望值)和预期要修改成的值传入
if (compareAndSet(current, next))
return next;
}
}
......
/**
* JDK文档对该方法的说明如下:如果当前状态值等于预期值,则以原子方式将同步状态设置为给定的更新值。
*
*/
public final boolean compareAndSet(int expect, int update) {
/**
首先可以看到AtomicInteger类在域中声明了这两个私有变量unsafe和valueOffset。
其中unsafe实例采用Unsafe类中静态方法getUnsafe()得到,
但是这个方法如果我们写的时候调用会报错,因为这个方法在调用时会判断类加载器,
我们的代码是没有“受信任”的,而在jdk源码中调用是没有任何问题的;
valueOffset这个是指类中相应字段在该类的偏移量,
在这里具体即是指value这个字段在AtomicInteger类的内存中相对于该类首地址的偏移量。
// 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"));// 反射出value属性,获取其在内存中的位置
} catch (Exception ex) {
throw new Error(ex);
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
比较并设置,这里利用Unsafe类的JNI方法实现,使用CAS指令,可以保证读-改-写是一个原子操作。
compareAndSwapInt有4个参数,
this - 当前AtomicInteger对象,
Offset - value属性在内存中的位置(需要强调的是:不是value值在内存中的位置,是value属性在内存中的位置),
expect - 预期值,update - 新值,根据上面的CAS操作过程,
当内存中的value值等于expect值时,则将内存中的value值更新为update值,并返回true,否则返回false。
在这里我们有必要对Unsafe有一个简单点的认识,从名字上来看,不安全,确实,这个类是用于执行低级别的、
不安全操作的方法集合,这个类中的方法大部分是对内存的直接操作,所以不安全,但当我们使用反射、并发包时,都间接的用到了Unsafe。
*/
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
}
再看unsafe.compareAndSwapInt(this, valueOffset, expect, update);源码:
可以发现期望值是我们 当时取得内存中的 private volatile int value;得到的 有可能已经被B线程更改,当前值是根据反射value属性字段 得到内存地址 得到的真实当前值
/**
首先可以看到AtomicInteger类在域中声明了这两个私有变量unsafe和valueOffset。
其中unsafe实例采用Unsafe类中静态方法getUnsafe()得到,
但是这个方法如果我们写的时候调用会报错,因为这个方法在调用时会判断类加载器,
我们的代码是没有“受信任”的,而在jdk源码中调用是没有任何问题的;
valueOffset这个是指类中相应字段在该类的偏移量,
在这里具体即是指value这个字段在AtomicInteger类的内存中相对于该类首地址的偏移量。
*/
// 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"));// 反射出value属性,获取其在内存中的位置
} catch (Exception ex) {
throw new Error(ex);
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
/**
比较并设置,这里利用Unsafe类的JNI方法实现,使用CAS指令,可以保证读-改-写是一个原子操作。
compareAndSwapInt有4个参数,
this - 当前AtomicInteger对象,
Offset - value属性在内存中的位置(需要强调的是:不是value值在内存中的位置,是value属性在内存中的位置),
expect - 预期值,update - 新值,根据上面的CAS操作过程,
当内存中的value值等于expect值时,则将内存中的value值更新为update值,并返回true,否则返回false。
在这里我们有必要对Unsafe有一个简单点的认识,从名字上来看,不安全,确实,这个类是用于执行低级别的、
不安全操作的方法集合,这个类中的方法大部分是对内存的直接操作,所以不安全,但当我们使用反射、并发包时,都间接的用到了Unsafe。
*/