使用LongAdder进行计数的Java实现

最新推荐文章于 2025-03-23 15:36:53 发布
最新推荐文章于 2025-03-23 15:36:53 发布
阅读量143 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 开发语言 算法 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CyberNerdX/article/details/133368337
Java 专栏收录该内容
233 篇文章 ¥59.90 ¥99.00
订阅专栏
本文介绍了Java中的LongAdder类，它在高并发环境下比AtomicLong更具性能优势。LongAdder通过分段技术减少线程竞争，提供increment()等方法进行计数操作，并且线程安全，无需额外同步。使用示例和关键方法进行了说明。

在Java中，LongAdder是一种用于高并发场景下的计数器实现。与传统的AtomicLong相比，LongAdder在高并发情况下具有更好的性能，因为它采用了一种分段的方式来减少竞争。

要使用LongAdder进行计数，首先需要创建一个LongAdder对象，并通过调用它的increment()方法来递增计数器的值。下面是一个简单的示例代码：

import java.util.concurrent.atomic.LongAdder;

public class CounterExample {
了解本专栏 订阅专栏 解锁全文
Java中的LongAdder函数：高效数字累加
HackLogic的博客
09-21 253
在Java中，LongAdder是一种用于高效执行数字累加操作的类。它是Java 8中引入的，并且在多线程环境下具有良好的性能。本文将详细介绍LongAdder的使用，并提供相应的源代码示例。首先，我们需要导入Java.util.concurrent包，以便使用LongAdder类。需要注意的是，LongAdder类还提供了其他一些方法，可以实现更复杂的操作。方法，该方法在获取累加结果后会将LongAdder的值重置为0，这在某些场景下非常有用。在上面的示例中，我们首先创建了一个LongAdder对象。
Java-多种方法实现多线程计数
兴趣是最好的老师
01-02 430
如果你只是需要一个线程安全的计数器，AtomicInteger可能是最简单的选择。如果你需要为多个不同的键进行计数，可以使用ConcurrentHashMap，它提供了线程安全的操。LongAdder是AtomicLong的替代品，特别适合高并发场景下的计数操作。如果你希望每个线程都有自己独立的计数器，可以使用ThreadLocal。ConcurrentHashMap：适用于需要为多个不同键计数的场景。ThreadLocal：适用于每个线程独立计数的场景。LongAdder：适用于高并发场景下的高效计数。
JDK8新增的原子操作类LongAdder
qq_39618266的博客
06-24 427
1.LongAdder简单介绍 AtomicLong通过CAS提供了非阻塞的原子性操作，相比使用阻塞算法的同步器来说它的性能己经很好了，但是JDK开发组并不满足于此。使用AtomicLong时，在高并发下大量线程会同时去竞争更新同一个原子变量，但是由于同时只有一个线程的CAS操作会成功，这就造成了大量程竞争失败后，会通过无限循环不断进行自旋尝试CAS的操作，而这会白白浪费CPU资源。 因此JK...
LongAdder和AtomicLong
zzcheng_gogo的博客
06-18 1144
LongAdder AmoticLong AtomicLong是作用是对长整形进行原子操作。 原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束。 在32位操作系统中，64位的long 和 double 变量由于会被JVM当作两个分离的32位来进行操作，所以不具有原子性。而使用AtomicLong能让long的操作保持原子型。 构造方法 AtomicLong() 创建一个新的AtomicLong，初始值为 0 。 AtomicLong(long initialValue)
LongAdder的应用和获取准确值的方法
weixin_45909775的博客
12-05 1524
项目场景： 使用LongAdder本地保存数据，定时的去拉取本地缓存中的数据更新到数据库。 问题描述： 因为Mentor要求我保存数据的时候要考虑高并发和性能问题，所以我也就想到了使用LongAdder。LongAdder在添加的时候性能会比AtomicInteger更好，原因在于其longAccumulate（）方法和getAndAddInt（）方法的区别，有兴趣的可以自己去看看源码。不得不说每次看完大神Doug Lea写的代码，就两个字牛逼。虽然LongAdder的性能比AtomicInteger更好
LongAdder解析
weixin_34319640的博客
01-24 273
 对LongAdder的最初了解是从Coolshell上的一篇文章中获得的，但是一直都没有深入的了解过其实现，只知道它相较于AtomicLong来说，更加适合写多读少的并发情景。今天，我们就研究一下LongAdder的原理，探究一下它如此高效的原因。 基本原理和思想  Java有很多并发控制机制，比如说以AQS为基础的锁或者以CAS为原理的自旋锁。不了解AQS的朋友可以阅读我之前的AQS源码解析文...
深入探讨Java中的LongAdder：使用技巧与避坑指南
龚小帅的博客
10-22 1501
LongAdder位于包中，是一种用于高效计数的类。它的功能类似于AtomicLong，但设计上更适合在高并发环境下使用。AtomicLong依赖于底层的**CAS（Compare-And-Swap）**机制，它通过不断重试来保证原子性。然而，在极高并发的场景中，CAS操作可能会频繁失败，导致性能下降。而LongAdder通过将计数分散到多个单独的变量中，并在最后累加，减少了竞争，从而在高并发场景下提升性能。LongAdder是什么？它是AtomicLong的替代品，设计用于高并发环境下的高效计数。
LongAdder 的底层实现原理
qq_36929638的博客
03-23 594
的核心思想是通过分散竞争来减少线程之间的冲突，从而提升性能。是 Java 中用于高效统计并发计数的一个类，它在高并发场景下比。如果需要更深入的源码分析或示例代码，我可以进一步提供！是一个简单的类，包含一个。
Java并发编程-Atomiclnteger、LongAdder等原子类的使用及案例实战
program哲学
06-30 536
详细介绍AtomicInteger、LongAdder关键字及相关应用案例实战
【java】并发类 LongAdder 介绍
小子宝丁的博客
05-06 549
LongAdder 是 JDK8 中新增的一个原子类型，它可以用于高并发场景下的计数器。相比于传统的 AtomicLong，LongAdder 的性能更好，在高并发场景下能够提供更好的性能。
JDK8系列之LongAdder解析
z69183787的专栏
02-24 829
前言 最近公司的项目在陆续升级jdk8，正好想起之前有人问我的jdk8中新增的LongAdder类和AtomicLong的区别，就忍不住想探究一番。 源码解析 首先看一下类的定义 public class LongAdder extends Striped64 implements Serializable 然后来看一下类的属性和方法 这里让我困惑的一个问题是LongAdder...
LongAdder原理
小小少年的博客
03-07 295
对于longAdder的应用，也是在看到concurrentHashMap源码中，统计数组中元素个数的时候，看到了Doug Lea写的一个注释，才开始去关注这个类，这里主要记录下自己对该类源码的学习笔记 longAdder核心思想 通常，在说到这个类的时候，会和atomic中原子类有关系，atomicInteger底层的话，通过unsafe中的native方法进行compareAndSwap方法去进行值的更新，同时，在atomic类中声明的value是volatile修饰，保证了可见性；这个是没问题的，但
原子操作类LongAdder
CoffeeAndMilk123的博客
07-10 429
LongAdder是一个原子性递增或者递减类，与AtomicLong的不同之处在于，LongAdder能够解决高并发情况下多线程同时竞争同意资源，而带来性能降低的问题。主要是通过将一个变量拆分为多个Cell,从而将单个变量的并发数分散到多个Cell上。关于LongAdder实现的几个分体如下： (1)LongAdder 的结构是怎样的？ (2)当前线程应该出问Cell 数组里面的哪一个Cell元素...
源码阅读:全方位讲解LongAdder
zqz_zqz的博客
04-26 6256
高并发下计数功能最好的数据结构就是LongAdder与DoubleAdder，低并发下效率也非常优秀，这是我见过的java并发包中设计的最为巧妙的类，从软硬件方面讲java并发编程优化到了极致，所以应该我们应该弄清楚它的每一行代码为什么要这样做，他俩的实现大同小异，下面我们以LongAdder类为例，来介绍下它的实现。longAdder简介它就是LongAdder在高并发情况下，提高性能的秘密武器，
深入解析Java并发库（JUC）中的LongAdder
码到三十五
03-01 1345
LongAdder是一个用于并发环境中的长整型加法操作的类，它提供了比AtomicLong更高的吞吐量。LongAdder在内部维护了一个或多个变量（取决于当前并发级别和系统环境），每个线程对其中一个变量进行操作，从而减少了线程间的竞争。当需要获取总和时，这些变量会被加在一起。与AtomicLong相比，它通过内部维护多个Cell对象，采用分段化的方式降低线程间的并发冲突，从而提高了性能。然而，这种设计也带来了一定的内存开销。LongAdder常用于需要高并发更新的统计和计数场景。
JDK8之LongAdder详解
java成神之路
07-06 1404
01该类的定义public class LongAdder extends Striped64 implements Serializable { priva...
Java JUC 之 atomic包下原子性操作
jtf19901223的博客
08-17 367
Java JUC 之 atomic包下的类是原子性操作； 其基于sun.misc.Unsafe类； Unsafe 类是直接操作内存的一个类； 其原子性就是基于Unsafe 来直接操作内存； 以AtomicBoolean 源码来看 // setup to use Unsafe.compareAndSwapInt for updates // 首先获取Unsafe 引用 private static final Unsafe unsafe = Unsafe.getUnsafe(); // 获取
LongAdder讲解
JMU_software19的博客
12-19 1945
思维导图.png 阿里巴巴开发手册.png 对于Java项目中计数统计的一些需求，如果是 JDK8，推荐使用 LongAdder 对象，比 AtomicLong 性能更好（减少乐观锁的重试次数） 在大多数项目及开源组件中，计数统计使用最多的仍然还是AtomicLong，虽然是阿里巴巴这样说，但是我们仍然要根据使用场景来决定是否使用LongAdder。 今天主要是来讲讲LongAdder的实现原理，还是老方式，通过图文一步步解开LongAdder神秘的面纱，通过此篇文章你会了解到： ...
longAdder 学习笔记
a867745320的博客
03-24 359
现在notion写的笔记,然后迁移过来,注释不对等凑合看,好不好嘛 相对于 atmoic,并发性能更墙,追求最终一致性,但是单一操作没有atmoic性能好 它是将所有并发所要储存的值放在一个base中, ,然后进行增减工作 将并发的线程,设计为一个数组,并将所要累加的值放入base中,base是cas操作,根据数组中元素是否为空,来进行最终的增改,多线程较多情况下,还会进行扩容,依然是二的次方幂,...
Java的LongAdder实现原理
最新发布
07-08
<think>我们正在讨论Java中的LongAdder类，这是一个用于高并发场景下计数的工具。根据引用，LongAdder通过分散竞争来提升性能。接下来，我将详细解释其工作原理和实现机制。 首先，LongAdder的设计目标是减少线程竞争。它采用了一个基础值（base）和一个单元格数组（cells），当没有竞争时，操作直接作用于base；当出现竞争时，会使用cells数组来分散更新。 核心思想：将单个值的更新压力分散到多个值上，最后在需要总和时进行汇总。 具体实现步骤： 1. 初始时，LongAdder内部有一个base值，所有更新操作都直接尝试更新base（通过CAS操作）。 2. 当多个线程竞争更新base时（即CAS失败），它会初始化一个cells数组（每个元素是一个Cell对象，内部是一个volatile long值），并将更新操作分散到数组的不同元素上。 3. 每个线程根据哈希算法映射到cells数组的一个位置，然后更新该位置的Cell值。这样，多个线程就可以同时更新不同的Cell，从而减少竞争。 4. 当需要获取当前总和时，将base和所有cells数组中的值相加即可。 注意：Cell数组是惰性初始化的，只有在发生竞争时才创建。此外，数组的大小会根据竞争情况动态扩展（比如从2扩容到4、8等），但不会无限扩容，有一个上限（通常是CPU核心数的一个倍数，因为超过核心数的线程数并不能真正并行）。 源码关键点（基于Java 17，具体实现可能因版本而异）： - LongAdder继承自Striped64类，Striped64中实现了核心的分段累加逻辑。 - Cell类使用@Contended注解避免伪共享（缓存行共享问题）。 - 核心方法： increment() -> 调用add(1L) add(long x) -> 尝试更新base，失败则进入cell更新逻辑 sum() -> 返回base与所有cell值的总和（注意：没有加锁，所以是一个近似值，但在没有并发更新时是准确的） 下面是一个简化的代码逻辑（非完整源码，仅展示关键步骤）： public void add(long x) { Cell[] cs; long b, v; int m; Cell c; // 首先尝试更新base if ((cs = cells) != null || !casBase(b = base, b + x)) { // 如果cells数组不为空（已经初始化过）或者更新base失败（说明有竞争），则进入 boolean uncontended = true; if (cs == null || (m = cs.length - 1) < 0 || (c = cs[getProbe() & m]) == null || !(uncontended = c.cas(v = c.value, v + x))) // 如果cells数组未初始化，或者当前线程对应的cell为空，或者更新cell失败，则调用longAccumulate方法 longAccumulate(x, null, uncontended); } } final boolean casBase(long cmp, long val) { return BASE.compareAndSet(this, cmp, val); } longAccumulate方法负责初始化cells数组，扩容，以及为线程分配cell等。 性能优势：在高并发下，多个线程可以同时更新不同的cell，从而大大减少竞争，提高吞吐量。但获取总和（sum）时，需要遍历整个cells数组，所以sum操作的开销相对较大，不适合频繁调用。 与AtomicLong比较：AtomicLong使用一个volatile变量，每次更新都需要CAS操作，高并发下CAS失败重试的开销大。而LongAdder通过分散热点，使得每个线程大部分时间操作自己独立的cell，竞争减少。 缺点：LongAdder在统计时可能会有精度损失（因为并发更新时，sum操作没有加锁，所以是某一时刻的快照，但最终一致）。另外，它占用更多的内存（cells数组）。 应用场景：适合高并发的计数，如统计请求次数、点击量等，但不适合需要精确实时获取值的场景（如控制流程）。 根据引用[4]中的例子，LongAdder常与ConcurrentHashMap结合使用，用于维护频率映射。 相关问题： §§相关问题§§ 1. LongAdder在哪些场景下比AtomicLong更有优势？ 2. LongAdder的sum()方法为什么在并发更新时不是精确的？ 3. 如何避免LongAdder中Cell数组的伪共享问题？ 4. LongAdder的初始化和扩容机制是怎样的？</think>### Java LongAdder 类的工作原理及实现机制 `LongAdder` 是 Java 并发库（`java.util.concurrent.atomic`）中用于高效处理高并发计数场景的类。其核心设计目标是通过**分散竞争**来提升性能，避免 `AtomicLong` 在高并发下的性能瓶颈[^1][^2]。以下是详细实现机制： --- #### **1. 核心设计思想** - **分散热点**：将单一共享变量的更新压力分散到多个变量（称为 `Cell`）上，减少线程竞争[^1][^5]。 - **空间换时间**：通过额外内存开销换取更高吞吐量，适用于统计场景（如计数、直方图）而非精确同步控制[^3]。 - **最终一致性**：结果不保证实时精确，但调用 `sum()` 时可获得最终一致的总和[^1]。 --- #### **2. 关键数据结构** ```java // 简化版源码（基于 OpenJDK） public class LongAdder extends Striped64 { // 基础值（无竞争时直接更新） transient volatile long base; // 动态扩容的 Cell 数组（处理竞争） transient volatile Cell[] cells; // Cell 内部类（避免伪共享） @sun.misc.Contended static final class Cell { volatile long value; Cell(long x) { value = x; } } } ``` - **`base`**：无竞争时的主计数器，通过 CAS 更新。 - **`cells` 数组**：当线程竞争 `base` 失败时，初始化数组并将更新分散到不同 `Cell` 元素[^5]。 - **`@Contended` 注解**：填充 `Cell` 的内存布局，防止 CPU 缓存行伪共享（False Sharing）[^5]。 --- #### **3. 工作流程** 以 `increment()` 为例： 1. **尝试更新 `base`** 使用 CAS 直接更新 `base`（低竞争时高效）。 ```java if (CAS(base, current, current + 1)) return; // 成功则退出 ``` 2. **竞争时转向 `cells` 数组** - 若 `cells` 未初始化，则创建大小为 2 的数组（惰性初始化）。 - 根据线程哈希值定位到某个 `Cell` 槽位： ```java int index = Thread.currentThread().hashCode() & (cells.length - 1); ``` - 对该 `Cell` 执行 CAS 更新（每个线程优先更新独立槽位）[^1][^5]。 3. **动态扩容** 若特定 `Cell` 槽位竞争仍激烈（CAS 失败），则扩容 `cells` 数组（通常翻倍），直到达到 CPU 核心数上限[^5]。 4. **求和（`sum()`）** 遍历所有 `Cell` 的值并累加到 `base`： ```java public long sum() { long sum = base; Cell[] cs = cells; if (cs != null) { for (Cell c : cs) if (c != null) sum += c.value; } return sum; // 注意：非原子快照 } ``` --- #### **4. 性能优势与代价** | **维度** | **LongAdder** | **AtomicLong** | |----------------|----------------------------------------|------------------------------| | **高并发吞吐量** | 极高（分散竞争）[^2][^5] | 低（CAS 竞争激烈时自旋开销大）| | **内存开销** | 较高（`Cell` 数组 + 填充）[^3][^5] | 低（单一变量） | | **结果精确性** | 最终一致（`sum()` 非原子）[^1] | 实时精确 | | **适用场景** | 统计计数（如 QPS 监控）[^4] | 细粒度同步控制 | --- #### **5. 典型应用场景** - **服务监控**：统计心跳请求次数（如引用[^4]的 `ServiceRegistry`）。 ```java Map<String, LongAdder> heartbeatCounters = new ConcurrentHashMap<>(); heartbeatCounters.computeIfAbsent(serviceId, k -> new LongAdder()).increment(); ``` - **频率统计**：与 `ConcurrentHashMap` 结合实现直方图（如引用[^3]）。 - **高并发计数器**：替代 `AtomicLong` 用于访问量统计等[^2][^5]。 --- #### **6. 局限性** - **非实时精确**：`sum()` 遍历时可能遗漏正在更新的值[^1]。 - **内存敏感场景慎用**：`Cell` 数组可能占用较多内存[^3]。 - **不适用于原子操作**：如比较交换（`compareAndSet`）需用 `AtomicLong`[^3]。 --- ### 相关问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值