面试官：说说Atomic原子类的实现原理

  •  线程安全真的是线程的安全吗?
  • 什么是 Atomic?
  • 实现一个计数器
  • AtomicInteger 源码分析
  • AtomicLong 和 LongAdder 谁更牛?
  • 总结

当我们谈论『线程安全』的时候，肯定都会想到 Atomic 类。不错，Atomic 相关类都是线程安全的，在讲 Atomic 类之前我想再聊聊『线程安全』这个概念。

10余年的织金网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整织金建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联公司从事“织金网站设计”,“织金网站推广”以来，每个客户项目都认真落实执行。

线程安全真的是线程的安全吗?

初看『线程安全』这几个字，很容易望文生义，这不就是线程的安全吗?其实不是，线程本身没有好坏，没有『安全的线程』和『不安全的线程』之分，俗话说：人之初性本善，线程天生也是纯洁善良的，真正让线程变坏是因为访问的变量的原因，变量对于操作系统来说其实就是内存块，所以绕了这么一大圈，线程安全称为『内存的安全』可能更为贴切。

简而言之，线程访问的内存决定了这个线程是否是安全的。

变量大致可以分为局部变量和共享变量，局部变量对于 JVM 来说是栈空间，大家都背过八股文，栈是线程私有的是非共享的，那自然也是内存安全的;共享变量对于 JVM 来说一般是存在于堆上，堆上的东西是所有线程共享的，如果不加任何限制自然是不安全的。

因为线程安全这个概念已经深入人心了，所以后面我们还是用线程安全来表达内存安全的含义。

那如何解决这种不安全呢?方法有很多，比如：加锁、Atomic 原子类等。

好了，咱们今天先来看看Atomic类。

什么是 Atomic?

Java从JDK1.5开始提供java.util.concurrent.atomic包，这里包含了多个原子操作类。原子操作类提供了一个简单、高效、安全的方式去更新一个变量。

Atomic 包下的原子操作类有很多，可以大致分为四种类型：

  • 原子操作基本类型
  • 原子操作数组类型
  • 原子操作引用类型
  • 原子操作更新属性

Atomic原子操作类在源码中都使用了Unsafe类，Unsafe类提供了硬件级别的原子操作，可以安全地直接操作内存变量。后面讲解源码时再详细介绍。

实现一个计数器

假如在业务代码中需要实现一个计数器的功能，啪地一下，很快我们就写出了以下的代码：

 
 
 
    
  
  
  
  1. public class Counter { 
    2. 
  
  
  
  2.     private int count; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public void increase() { 
    5. 
  
  
  
  5.         count++; 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8.

increase方法对 count 变量进行递增。

当代码提交上库进行code review时，啪地一下，很快收到了检视意见(严重级别)：

如果在多线程场景下，你的计数器可能有问题。

上大一的时候老师就讲过 count++ 是非原子性的，它实际上包含了三个操作：读数据，加一，写回数据。

再次修改代码，多线访问increase方法会有问题，那就给它加个锁吧，count变量修改了其他线程可能不能即时看到，那就给变量加个 volatile 吧。

吭哧吭哧，代码如下：

 
 
 
    
  
  
  
  1. public class LockCounter { 
    2. 
  
  
  
  2.     private volatile int count; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public synchronized void increase() { 
    5. 
  
  
  
  5.         count++; 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8.

一顿操作猛如虎，再次提交代码后，依然收到了检视意见(建议级别)：

加锁会影响效率，可以考虑使用原子操作类。

原子操作类?「黑人问号脸」，莫不是大佬知道我晚上有约会故意整我，不想合入代码吧。带着将信将疑的态度，打开百度谷歌，原来 AtomicInteger 可以轻松解决这个问题，手忙脚乱一顿复制粘贴代码搞定了，终于可以下班了。

 
 
 
    
  
  
  
  1. public class AtomicCounter { 
    2. 
  
  
  
  2.     private AtomicInteger count = new AtomicInteger(0); 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public void increase() { 
    5. 
  
  
  
  5.         count.incrementAndGet(); 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8.

AtomicInteger 源码分析

调用AtomicInteger类的incrementAndGet方法不用加锁可以实现安全的递增，这个好神奇，下面带领大家分析一下源码是这么实现的，等不及了等不及了。

打开源码，可以看到定义的incrementAndGet方法：

 
 
 
    
  
  
  
  1. /** 
    2. 
  
  
  
  2. * 在当前值的基础上自动加 1 
    3. 
  
  
  
  3. * 
    4. 
  
  
  
  4. * @return 更新后的值 
    5. 
  
  
  
  5. */ 
    6. 
  
  
  
  6. public final int incrementAndGet() { 
    7. 
  
  
  
  7.     return unsafe.getAndAddInt(this, valueOffset, 1) + 1; 
    8. 
  
  
  
  8. } 
    9.

通过源码可以看到实际上是调用了 unsafe 的一个方法，unsafe 是什么待会再说。

我们再看看getAndAddInt方法的参数：第一个参数 this 是当前对象的引用;第二个参数valueOffset是用来记录value值在内存中的偏移地址，第三个参数是一个常量 1;

在 AtomicInteger 中定义了一个常量valueOffset和一个可变的成员变量 value：

 
 
 
    
  
  
  
  1. private static final Unsafe unsafe = Unsafe.getUnsafe(); 
    2. 
  
  
  
  2. private static final long valueOffset; 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. static { 
    5. 
  
  
  
  5.     try { 
    6. 
  
  
  
  6.         valueOffset = unsafe.objectFieldOffset 
    7. 
  
  
  
  7.             (AtomicInteger.class.getDeclaredField("value")); 
    8. 
  
  
  
  8.     } catch (Exception ex) { throw new Error(ex); } 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11. private volatile int value; 
    12.

value 变量保存当前对象的值，valueOffset 是变量的内存偏移地址，也是通过调用unsafe的方法获取。

 
 
 
    
  
  
  
  1. public final class Unsafe { 
    2. 
  
  
  
  2.     // ……省略其他方法 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public native long objectFieldOffset(Field f); 
    5. 
  
  
  
  5. } 
    6.

这里再说说 Unsafe 这个类，人如其名：不安全的类。打开 Unsafe 类会看到大部分方法都标识了 native，也就是说这些都是本地方法，本地方法强依赖于操作系统平台，一般都是采用C/C++语言编写，在调用 Unsafe 类的本地方法实际会执行这些方法，熟悉 C/C++的小伙伴可自行下载源码研究。

好了，我们再回到最开始，调用了 Unsafe 类的getAndAddInt方法：

 
 
 
    
  
  
  
  1. public final class Unsafe { 
    2. 
  
  
  
  2.     // ……省略其他方法 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4.     public final int getAndAddInt(Object o, long offset, int delta) { 
    5. 
  
  
  
  5.         int v; 
    6. 
  
  
  
  6.         do { 
    7. 
  
  
  
  7.             v = getIntVolatile(o, offset);  
    8. 
  
  
  
  8.             // 循环 CAS 操作 
    9. 
  
  
  
  9.         } while (!compareAndSwapInt(o, offset, v, v + delta)); 
    10. 
  
  
  
  10.         return v; 
    11. 
  
  
  
  11.     } 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13.     // 根据内存偏移地址获取当前值 
    14. 
  
  
  
  14.     public native int getIntVolatile(Object o, long offset); 
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.     // CAS 操作 
    17. 
  
  
  
  17.     public final native boolean compareAndSwapInt(Object o, long offset, 
    18. 
  
  
  
  18.                                                   int expected, 
    19. 
  
  
  
  19.                                                   int x); 
    20. 
  
  
  
  20. } 
    21.

通过getIntVolatile方法获取当前 AtomicInteger 对象的value值，这是一个本地方法。

然后调用compareAndSwapInt进行 CAS 原子操作，尝试在当前值的基础上加 1，如果 CAS 失败会循环进行重试。

因此compareAndSwapInt方法是最核心的，详细实现大家可以自行找源码看。这里我们看看方法的参数，一共有四个参数：o 是指当前对象;offset 是指当前对象值的内存偏移地址;expected是期望值;x是修改后的值;

compareAndSwapInt方法的思路是拿到对象 o 和 offset 后会再去取对象实际的值，如果当前值与之前取的期望值是一致的就认为 value 没有被修改过，直接将 value 的值更新为 x，这样就完成了一次 CAS 操作，CAS 操作是通过操作系统保证原子性的。

如果当前值与期望值不一致，说明 value 值被修改过，那么就会重试 CAS 操作直到成功。

AtomicInteger类中还有很多其他的方法，如：

 
 
 
    
  
  
  
  1. decrementAndGet() 
    2. 
  
  
  
  2. getAndDecrement() 
    3. 
  
  
  
  3. getAndIncrement() 
    4. 
  
  
  
  4. accumulateAndGet() 
    5. 
  
  
  
  5. // …… 省略 
    6.

这些方法实现原理都是大同小异，希望大家可以举一反三理解其他的方法。

另外还有一些其他的类，如：AtomicLong，AtomicReference，AtomicIntegerArray等，这里也不再赘述，原理都是大同小异。

AtomicLong 和 LongAdder 谁更牛?

Java 在 jdk1.8版本 引入了 LongAdder 类，与 AtomicLong 一样可以实现加、减、递增、递减等线程安全操作，但是在高并发竞争非常激烈的场景下 LongAdder 的效率更胜一筹，后续单独用一篇文章进行介绍。

总结

讲了半天，可能有的小伙伴还是比较懵，Atomic 类到底是如何实现线程安全的?

在语言层面上，Atomic 类是没有做任何同步操作的，翻看源代码方法没有任何加锁，其实最大功劳还是在 CAS 身上。CAS 利用操作系统的硬件特性实现了原子性，利用 CPU 多核能力实现了硬件层面的阻塞。

只有 CAS 的原子性保证就一定是线程安全的吗?当然不是的，通过源码发现 value 变量还用了 volatile 修饰了，保证了线程可见性。

那有些小伙伴可能要问了，那是不是加锁就没有用了，非也，虽然基于 CAS 的线程安全机制很好很高效，但是这适合一些粒度比较小的需求才有效，如果遇到非常复杂的业务逻辑还是需要加锁操作的。

大家学会了吗?

网站题目：面试官：说说Atomic原子类的实现原理
本文链接：http://www.gawzjz.com/qtweb/news3/167003.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站制作知识

同城分类信息

广汉锦华建材　　 　成都网站推广　　 　服务器托管　　 　德阳网站建设　　 　温江做网站　　 　公路钻孔机　　 　成都网站推广　　 　成都光华机房　　 　水泥基自流平　　 　达州主机托管　　 　宜宾做网站　　 　网上商城管理系统　　 　成都主机租用　　 　乐山企业网站设计　　 　成都外贸网站优化　　 　成都网站制作　　 　网站制作　　 　网站报价方案　　 　边坡防护网　　 　重庆移动机房托管