Java并发编程之原子更新类AtomicIntegerFieldUpdater的实例

RRT冻羊

发布于 2022-11-03 13:10:46

2660

发布于 2022-11-03 13:10:46

文章被收录于专栏：冻羊技术思考冻羊技术思考

本篇文章不会教你怎么用AtomicIntegerFieldUpdater类，也不会给你讲解里面的机制，本篇只是最直观的提供一个demo，来让你直观的感知到原子更新类的效果

What is AtomicIntegerFieldUpdater

AtomicIntegerFieldUpdater就是用来更新某一个实例对象里面的int属性的。但是注意，在用法上有规则：

字段必须是volatile类型的，在线程之间共享变量时保证立即可见
字段的描述类型（修饰符public/protected/default/private）是与调用者与操作对象字段的关系一致。也就是说调用者能够直接操作对象字段，那么就可以反射进行原子操作。
对于父类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。
只能是可修改变量，不能使final变量，因为final的语义就是不可修改。
只能是实例变量，不能是类变量，也就是说不能加static关键字。
对于AtomicIntegerFieldUpdater和AtomicLongFieldUpdater只能修改int/long类型的字段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用AtomicReferenceFieldUpdater。

具体一个demo来感受

简单说明该demo： 例子定义了一个int inet 的变量，通过简单的inet++ 运算来说明在高并发场景下，非原子更新会造成的后果。 为了方便你理解，这里简单讲解一下 inet++ 在Java中的底层原理： 我们知道，所有高级自然语言（java，c，c++），最终都会被编译成机器能识别的字节码（如果你不明白计什么是字节码，可以去百度，如果你是大学生，你只要学过《计算机组成原理》和《编译原理》，你就会明白大概是怎么一回事）

而inet++在底层中，通俗的讲，他的字节码产生的作用顺序是这样的：

取出变量inet中的值保存到某个地方
然后从某个地方取出这个值，进行+1运算
运算完成后再赋值回inet

（我们可以看出，inet++在Java的底层，是如何工作的）（这种例子在数据库事务，锁的知识体系里面，经常可见，比如银行的钱包转账问题，就需要完成原子性操作）（通过上述的解释，我们知道在Java中对int类型的变量进行++操作，是拆分为几个步骤完成的，它是非原子更新的，所以会产生并发问题）

在高并发场景下，就会出现这样的问题 类似的场景：订票系统，钱包扣费系统，计数系统等目的：有N个线程操作inet++，inet的结果就应该为N 并发问题出现后：inet的结果会 < N

（如下图：2个线程在并发场景下，执行inet++的操作。但是由于没有加锁，inet++不满足CAS原子更新，因此就会出现结果不为3的情况。预期结果，1+2=3。但是由于出现了并发问题，inet最终是2）

下面贴出代码

通过两个方法的结果来直观感受 一个是使用了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++的操作。

在使用了AtomicIntegerFieldUpdater原子更新后，inte最终结果为10000没有错。
而第二个方法，没有使用任何技术实现原子更新，可以看出inte的结果小于10000

通过这段代码和例子，来解释AtomicIntegerFieldUpdater类的实际使用效果。如果你对AtomicIntegerFieldUpdater类有兴趣，可以去查看其他作者的技术文献，本篇内容的目的仅仅是直观感受这个类在并发编程中的其中一个作用。

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019-06-21，如有侵权请联系 cloudcommunity@tencent.com 删除

压力测试

编程算法

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

压力测试

编程算法

java

登录后参与评论

0 条评论

热度