原子操作类AtomicInteger详解

程序员文章站 2022-05-03 19:18:37

...

建议看原文，格式更清晰：https://blog.csdn.net/fanrenxiang/article/details/80623884

为什么需要AtomicInteger原子操作类？

对于Java中的运算操作，例如自增或自减，若没有进行额外的同步操作，在多线程环境下就是线程不安全的。num++解析为num=num+1，明显，这个操作不具备原子性，多线程并发共享这个变量时必然会出现问题。测试代码如下:





public class AtomicIntegerTest {



 



    private static final int THREADS_CONUT = 20;



    public static int count = 0;



 



    public static void increase() {



        count++;



    }



 



    public static void main(String[] args) {



        Thread[] threads = new Thread[THREADS_CONUT];



        for (int i = 0; i < THREADS_CONUT; i++) {



            threads[i] = new Thread(new Runnable() {



                @Override




                public void run() {



                    for (int i = 0; i < 1000; i++) {



                        increase();



                    }



                }



            });



            threads[i].start();



        }



 



        while (Thread.activeCount() > 1) {



            Thread.yield();



        }



        System.out.println(count);



    }



}

这里运行了20个线程，每个线程对count变量进行1000此自增操作，如果上面这段代码能够正常并发的话，最后的结果应该是20000才对，但实际结果却发现每次运行的结果都不相同，都是一个小于20000的数字。这是为什么呢？

要是换成volatile修饰count变量呢？

顺带说下volatile关键字很重要的两个特性:

1、保证变量在线程间可见，对volatile变量所有的写操作都能立即反应到其他线程中，换句话说，volatile变量在各个线程中是一致的（得益于java内存模型—"先行发生原则"）；

2、禁止指令的重排序优化；

那么换成volatile修饰count变量后，会有什么效果呢？试一试:





public class AtomicIntegerTest {



 



    private static final int THREADS_CONUT = 20;



    public static volatile int count = 0;



 



    public static void increase() {



        count++;



    }



 



    public static void main(String[] args) {



        Thread[] threads = new Thread[THREADS_CONUT];



        for (int i = 0; i < THREADS_CONUT; i++) {



            threads[i] = new Thread(new Runnable() {



                @Override




                public void run() {



                    for (int i = 0; i < 1000; i++) {



                        increase();



                    }



                }



            });



            threads[i].start();



        }



 



        while (Thread.activeCount() > 1) {



            Thread.yield();



        }



        System.out.println(count);



    }



}

结果似乎又失望了，测试结果和上面的一致，每次都是输出小于20000的数字。这又是为什么么？上面的论据是正确的，也就是上面标红的内容，但是这个论据并不能得出"基于volatile变量的运算在并发下是安全的"这个结论，因为核心点在于java里的运算（比如自增）并不是原子性的。

用了AtomicInteger类后会变成什么样子呢？

把上面的代码改造成AtomicInteger原子类型，先看看效果





import java.util.concurrent.atomic.AtomicInteger;



 




public class AtomicIntegerTest {



 



    private static final int THREADS_CONUT = 20;



    public static AtomicInteger count = new AtomicInteger(0);



 



    public static void increase() {



        count.incrementAndGet();



    }



 



    public static void main(String[] args) {



        Thread[] threads = new Thread[THREADS_CONUT];



        for (int i = 0; i < THREADS_CONUT; i++) {



            threads[i] = new Thread(new Runnable() {



                @Override




                public void run() {



                    for (int i = 0; i < 1000; i++) {



                        increase();



                    }



                }



            });



            threads[i].start();



        }



 



        while (Thread.activeCount() > 1) {



            Thread.yield();



        }



        System.out.println(count);



    }



}

结果每次都输出20000，程序输出了正确的结果，这都归功于AtomicInteger.incrementAndGet()方法的原子性。

非阻塞同步

同步：多线程并发访问共享数据时，保证共享数据再同一时刻只被一个或一些线程使用。

我们知道，阻塞同步和非阻塞同步都是实现线程安全的两个保障手段，非阻塞同步对于阻塞同步而言主要解决了阻塞同步中线程阻塞和唤醒带来的性能问题，那什么叫做非阻塞同步呢？在并发环境下，某个线程对共享变量先进行操作，如果没有其他线程争用共享数据那操作就成功；如果存在数据的争用冲突，那就才去补偿措施，比如不断的重试机制，直到成功为止，因为这种乐观的并发策略不需要把线程挂起，也就把这种同步操作称为非阻塞同步（操作和冲突检测具备原子性）。在硬件指令集的发展驱动下，使得 "操作和冲突检测" 这种看起来需要多次操作的行为只需要一条处理器指令便可以完成，这些指令中就包括非常著名的CAS指令（Compare-And-Swap比较并交换）。《深入理解Java虚拟机第二版.周志明》第十三章中这样描述关于CAS机制:

原子操作类AtomicInteger详解 — 图取自《深入理解Java虚拟机第二版.周志明》13.2.2

所以再返回来看AtomicInteger.incrementAndGet()方法，它的时间也比较简单




    /**




     * Atomically increments by one the current value.



     *



     * @return the updated value



     */



    public final int incrementAndGet() {



        for (;;) {



            int current = get();



            int next = current + 1;



            if (compareAndSet(current, next))



                return next;



        }



    }

incrementAndGet()方法在一个无限循环体内，不断尝试将一个比当前值大1的新值赋给自己，如果失败则说明在执行"获取-设置"操作的时已经被其它线程修改过了，于是便再次进入循环下一次操作，直到成功为止。这个便是AtomicInteger原子性的"诀窍"了，继续进源码看它的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 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);



    }

可以看到，compareAndSet()调用的就是Unsafe.compareAndSwapInt()方法，即Unsafe类的CAS操作。

使用示例如下图，用于标识程序执行过程中是否发生了异常，使用quartz实现高级定制化定时任务（包含管理界面）实现中:

原子操作类AtomicInteger详解

原子操作类AtomicInteger详解参考资料：《深入理解Java虚拟机第二版》

原子操作类AtomicInteger详解引申阅读: 使用quartz实现高级定制化定时任务（包含管理界面）

原子操作类AtomicInteger详解推荐阅读:elastic search搜索引擎实战demo:https://github.com/simonsfan/springboot-quartz-demo，分支:feature_es

                    <li class="tool-item tool-active is-like "><a href="javascript:;"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#csdnc-thumbsup"></use>
                    </svg><span class="name">点赞</span>
                    <span class="count">36</span>
                    </a></li>
                    <li class="tool-item tool-active is-collection "><a href="javascript:;" data-report-click="{&quot;mod&quot;:&quot;popu_824&quot;}"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#icon-csdnc-Collection-G"></use>
                    </svg><span class="name">收藏</span></a></li>
                    <li class="tool-item tool-active is-share"><a href="javascript:;"><svg class="icon" aria-hidden="true">
                        <use xlink:href="#icon-csdnc-fenxiang"></use>
                    </svg>分享</a></li>
                    <!--打赏开始-->
                                            <!--打赏结束-->
                                            <li class="tool-item tool-more">
                        <a>
                        <svg t="1575545411852" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="5717" xmlns:xlink="http://www.w3.org/1999/xlink" width="200" height="200"><defs><style type="text/css"></style></defs><path d="M179.176 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5718"></path><path d="M509.684 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5719"></path><path d="M846.175 499.222m-113.245 0a113.245 113.245 0 1 0 226.49 0 113.245 113.245 0 1 0-226.49 0Z" p-id="5720"></path></svg>
                        </a>
                        <ul class="more-box">
                            <li class="item"><a class="article-report">文章举报</a></li>
                        </ul>
                    </li>
                                        </ul>
            </div>
                        </div>
        <div class="person-messagebox">
            <div class="left-message"><a href="https://blog.csdn.net/fanrenxiang">
                <img src="https://profile.csdnimg.cn/F/1/9/3_fanrenxiang" class="avatar_pic" username="fanrenxiang">
                                        <img src="https://g.csdnimg.cn/static/user-reg-year/1x/2.png" class="user-years">
                                </a></div>
            <div class="middle-message">
                                    <div class="title"><span class="tit"><a href="https://blog.csdn.net/fanrenxiang" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;}" target="_blank">饭一碗</a></span>
                                                <span class="flag expert">
                            <a href="https://blog.csdn.net/home/help.html#classicfication" target="_blank">
                                <svg class="icon" aria-hidden="true">
                                    <use xlink:href="#csdnc-blogexpert"></use>
                                </svg>
                                博客专家
                            </a>
                        </span>
                                        </div>
                <div class="text"><span>发布了199 篇原创文章</span> · <span>获赞 518</span> · <span>访问量 134万+</span></div>
            </div>
                            <div class="right-message">
                                        <a href="https://bbs.csdn.net/forums/p-fanrenxiang" target="_blank" class="btn btn-sm btn-red-hollow bt-button personal-messageboard">他的留言板
                    </a>
                                                        <a class="btn btn-sm  bt-button personal-watch" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;}">关注</a>
                                </div>
                        </div>
    </div>
</article>

相关标签：《java面试题全集》疑点详解并发编程大厂任性挑 AtomicInteger

上一篇： jdbc实现简单的分组聚合统计查询

下一篇：仙境般的桃源秘境林芝赏花完整攻略

原子操作类AtomicInteger详解

建议看原文，格式更清晰：https://blog.csdn.net/fanrenxiang/article/details/80623884

为什么需要AtomicInteger原子操作类？

要是换成volatile修饰count变量呢？

用了AtomicInteger类后会变成什么样子呢？

非阻塞同步

JavaSE文件操作工具类FileUtil详解

Python类的继承、多态及获取对象信息操作详解

php实现的操作excel类详解

MongoDB模糊查询操作案例详解(类关系型数据库的 like 和 not like)

详解nodejs操作mongodb数据库封装DB类

PHP面向对象程序设计子类扩展父类（子类重新载入父类）操作详解

PHP类与对象后期静态绑定操作实例详解

PHP中信息格式化操作详解（MessageFormatter类）

比较volatile下count++和 AtomicInteger自增中原子操作问题

Python文件操作类操作实例详解