AtomicIntegerFieldUpdater就是用来更新某一个实例对象里面的int属性的。 但是注意,在用法上有规则:
简单说明该demo: 例子定义了一个int inet 的变量,通过简单的inet++ 运算来说明在高并发场景下,非原子更新会造成的后果。 为了方便你理解,这里简单讲解一下 inet++ 在Java中的底层原理: 我们知道,所有高级自然语言(java,c,c++),最终都会被编译成机器能识别的字节码(如果你不明白计什么是字节码,可以去百度,如果你是大学生,你只要学过《计算机组成原理》和《编译原理》,你就会明白大概是怎么一回事)
而inet++在底层中,通俗的讲,他的字节码产生的作用顺序是这样的:
(我们可以看出,inet++在Java的底层,是如何工作的) (这种例子在数据库事务,锁的知识体系里面,经常可见,比如银行的钱包转账问题,就需要完成原子性操作) (通过上述的解释,我们知道在Java中对int类型的变量进行++操作,是拆分为几个步骤完成的,它是非原子更新的,所以会产生并发问题)
在高并发场景下,就会出现这样的问题 类似的场景:订票系统,钱包扣费系统,计数系统等 目的:有N个线程操作inet++,inet的结果就应该为N 并发问题出现后:inet的结果会 < N
通过两个方法的结果来直观感受 一个是使用了AtomicIntegerFieldUpdater类来达到整形变量CAS原子更新。 另外一个方法为没有任何并发控制的普通代码
public class AtomIntegerFieldUpdateDemo {
//控制并发数量
final static int THREAD_NUM = 10000;
/*
* main方法
*/
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("----------- start testWithAtomic() --------------");
try {
AtomIntegerFieldUpdateDemo.testWithAtmoic();
} catch (InterruptedException e) {
System.out.println("---------- Error: " + e.getCause().getMessage());
}
}
});
t1.start();
t1.join();
System.out.println("\n=========== 结束testWithAtomic ===============");
System.out.println("\n ------------------ start testWithoutAtomic() ----------------------");
testWithoutAtmoic();
System.out.println(" ################## End of this demo ################# ");
}
/**
* 使用了AtomicIntegerFieldUpdater类控制int变量原子更新的方法
*/
public static void testWithAtmoic () throws InterruptedException {
AtomicIntegerFieldUpdater<DemoBean> atom = AtomicIntegerFieldUpdater.newUpdater(DemoBean.class, "inte");
DemoBean bean = new DemoBean();
CountDownLatch latch = new CountDownLatch(THREAD_NUM);
final boolean[] isOk = {false};
for (int i = 0; i < THREAD_NUM; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
SecureRandom secureRandom = new SecureRandom();
Thread.sleep(secureRandom.nextInt(10) * 10L /* 0~9随机数 乘以100ms */);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (atom.getAndIncrement(bean) == THREAD_NUM-1) {
isOk[0] = true;
}
latch.countDown();
}
}).start();
}
latch.await();
System.out.println("高并发结果:" + isOk[0] + "\n"
+ "inte: " + bean.inte);
}
/**
* 无使用原子更新,无法解决高并发场景下,原子问题。
* 最终结果isOk大概率是false,inte的结果大概率小于THREAD_NUM
*
* 出现并发的原因主要是“原子性"没有满足
* 高并发下,bean.inet++(非原子性)操作,可能会在某一时刻,2个线程都拿到inet=1,然后对1进行++,得到2.
* 这样本来2个线程的结果inet应该是加2次,变为3 。但是这里却只得到2
*
* 因此可以通过jdk1.5并发编程提供的工具类实现int的原子操作。或者自己实现原子性(如使用锁)
*/
public static void testWithoutAtmoic() throws InterruptedException {
DemoBean bean = new DemoBean();
CountDownLatch latch = new CountDownLatch(THREAD_NUM);
final boolean[] isOk = {false};
for (int i = 0; i < THREAD_NUM; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
SecureRandom secureRandom = new SecureRandom();
Thread.sleep(secureRandom.nextInt(10) * 10L /* 0~9随机数 乘以100ms */);
} catch (InterruptedException e) {
e.printStackTrace();
}
bean.inte++; //此处在高并发场景下,会出现并发问题
if (bean.inte == THREAD_NUM) {
isOk[0] = true;
}
latch.countDown();
}
}).start();
}
latch.await();
System.out.println("高并发结果:" + isOk[0] + "\n"
+ "inte: " + bean.inte);
}
}
class DemoBean {
volatile int inte;
public DemoBean() {
this.inte = 0;
}
}
可以看出,10000个线程在高并发场景下执行inet++的操作。