社区编辑申请
注册/登录
Java并发编程包中atomic的实现原理
开发 开发工具
在多线程的场景中,我们需要保证数据安全,就会考虑同步的方案,通常会使用synchronized或者lock来处理,使用了synchronized意味着内核态的一次切换。这是一个很重的操作。

 这是一篇来自粉丝的投稿,作者【林湾村龙猫】最近在阅读Java源码,这一篇是他关于并发包中atomic类的源码阅读的总结。Hollis做了一点点修改。

引子

在多线程的场景中,我们需要保证数据安全,就会考虑同步的方案,通常会使用synchronized或者lock来处理,使用了synchronized意味着内核态的一次切换。这是一个很重的操作。

有没有一种方式,可以比较便利的实现一些简单的数据同步,比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。

使用例子

  1. import java.util.concurrent.CountDownLatch; 
  2. import java.util.concurrent.atomic.AtomicInteger; 
  3.  
  4. public class App { 
  5.  
  6.     public static void main(String[] args) throws Exception { 
  7.         CountDownLatch countDownLatch = new CountDownLatch(100); 
  8.  
  9.         AtomicInteger atomicInteger = new AtomicInteger(0); 
  10.         for (int i = 0; i < 100; i++) { 
  11.             new Thread() { 
  12.                 @Override 
  13.                 public void run() { 
  14.                     atomicInteger.getAndIncrement(); 
  15.  
  16.                     countDownLatch.countDown(); 
  17.                 } 
  18.             }.start(); 
  19.         } 
  20.  
  21.         countDownLatch.await(); 
  22.  
  23.         System.out.println(atomicInteger.get()); 
  24.     } 

在以上代码中,使用AtomicInteger声明了一个全局变量,并且在多线程中进行自增,代码中并没有进行显示的加锁。

以上代码的输出结果,永远都是100。如果将AtomicInteger换成Integer,打印结果基本都是小于100。

也就说明AtomicInteger声明的变量,在多线程场景中的自增操作是可以保证线程安全的。接下来我们分析下其原理。

原理

我们可以看一下AtomicInteger的代码

他的值是存在一个volatile的int里面。volatile只能保证这个变量的可见性。不能保证他的原子性。

可以看看getAndIncrement这个类似i++的函数,可以发现,是调用了UnSafe中的getAndAddInt。

UnSafe是何方神圣?UnSafe提供了java可以直接操作底层的能力。

进一步,我们可以发现实现方式:

如何保证原子性:自旋 + CAS(乐观锁)。在这个过程中,通过compareAndSwapInt比较更新value值,如果更新失败,重新获取旧值,然后更新。

优缺点

CAS相对于其他锁,不会进行内核态操作,有着一些性能的提升。但同时引入自旋,当锁竞争较大的时候,自旋次数会增多。cpu资源会消耗很高。

换句话说,CAS+自旋适合使用在低并发有同步数据的应用场景。

Java 8做出的改进和努力

在Java 8中引入了4个新的计数器类型,LongAdder、LongAccumulator、DoubleAdder、DoubleAccumulator。他们都是继承于Striped64。

在LongAdder 与AtomicLong有什么区别?

Atomic*遇到的问题是,只能运用于低并发场景。因此LongAddr在这基础上引入了分段锁的概念。可以参考《JDK8系列之LongAdder解析》一起看看做了什么。

大概就是当竞争不激烈的时候,所有线程都是通过CAS对同一个变量(Base)进行修改,当竞争激烈的时候,会将根据当前线程哈希到对于Cell上进行修改(多段锁)。

可以看到大概实现原理是:通过CAS乐观锁保证原子性,通过自旋保证当次修改的最终修改成功,通过降低锁粒度(多段锁)增加并发性能。

【本文是51CTO专栏作者Hollis的原创文章,作者微信公众号Hollis(ID:hollischuang)】

戳这里,看该作者更多好文

责任编辑:武晓燕 来源: 51CTO专栏
相关推荐

2019-11-07 09:20:29

Java线程操作系统

2021-06-07 17:12:22

线程安全Atomic

2021-12-27 10:13:51

2021-08-05 12:41:57

2020-09-21 06:43:59

AtomicIntegNumber内存

同话题下的热门内容

使用VScode的几点感受,对比Pycharm、Jupyter优劣势分布式锁工具:RedissonGitHub 添加工具以简化软件开发管理用 Antlr 重构脚本解释器

编辑推荐

终于有人把Elasticsearch原理讲透了!花了一个星期,我终于把RPC框架整明白了!这可能是把ZooKeeper概念讲的最清楚的一篇文章论如何下载一个在线的m3u8文件到本地成为一个mp4!拜托!面试不要再问我Spring Cloud底层原理
我收藏的内容
点赞
收藏

51CTO技术栈公众号