LongAdder是什么，怎么使用

<think>好的，我现在需要回答用户关于LongAdder是什么以及如何使用的问题。用户之前已经问过CAS的三大核心问题，其中提到了LongAdder作为解决自旋开销问题的方案。因此，用户可能已经有一定的并发编程基础，现在想深入了解LongAdder的具体实现和用法。 首先，我要确定LongAdder的基本定义，它是JDK1.8引入的一个类，用于在高并发场景下高效地处理计数。接下来需要解释它与AtomicLong的区别，重点在于分段CAS的设计思想，减少竞争，提高吞吐量。 然后，用户需要知道如何使用LongAdder。应该给出具体的代码示例，包括初始化、累加、获取结果以及重置方法。这些例子要简洁明了，让用户能够直接复制使用。 同时，要说明适用场景，比如高并发写多读少的情况，以及不适合的场景，比如需要强一致性的实时读取。这里可能需要对比LongAdder和AtomicLong的性能差异，参考之前提到的性能表格，强调线程数多时的优势。 底层原理部分需要简要解释分段机制，比如Cell数组和base变量，如何通过哈希分散线程竞争。这部分不需要太深入，但要让用户明白为什么LongAdder更高效。 注意事项方面，要提到sum()方法的准确性、内存消耗以及重置的风险。这些都是用户在实际使用中可能遇到的坑，提前告知可以避免误用。 最后，总结使用建议，帮助用户根据具体场景选择合适的工具。可能还需要提到JDK版本要求，确保用户知道LongAdder需要1.8及以上版本。 现在需要检查是否有遗漏的信息，比如是否提到了add()和increment()方法，以及reset()的谨慎使用。另外，确保代码示例正确，没有语法错误，并且用中文注释方便理解。还要注意避免技术术语过于复杂，保持解释的易懂性。 可能用户的实际问题是如何在高并发程序中优化计数器性能，因此需要强调LongAdder的优势和适用条件。同时，提醒用户虽然LongAdder提高了性能，但在读取时可能需要容忍一定的误差，根据业务需求权衡。 最后，结构要清晰，分点说明，使用标题和代码块增强可读性，符合用户之前提供的格式要求。确保回答真实可靠，参考官方文档或权威资料，避免错误信息。</think>--- ### 一、LongAdder 是什么？ **LongAdder** 是 JDK 1.8 引入的高并发场景下的高性能计数器，专为解决 `AtomicLong` 在多线程竞争时的性能瓶颈而设计。其核心思想是 **分段累加（Cell 分散）**，通过将热点数据拆分成多个单元（Cell），减少线程竞争，提升吞吐量。 #### 与 AtomicLong 的对比 | 特性 | AtomicLong | LongAdder | |---------------------|-----------------------------|-----------------------------| | **实现方式** | 单一变量 CAS 自旋 | 分段 Cell 数组 + base 值 | | **高并发写性能** | 差（线程竞争激烈时自旋开销大） | 优（分散竞争，吞吐量提升数倍） | | **读操作一致性** | 强一致（直接返回值） | 最终一致（sum() 是近似值） | | **适用场景** | 低并发或需要精确读 | 高并发写多读少（如统计点击数） | --- ### 二、LongAdder 的使用方法 #### 1. 基本操作 ```java import java.util.concurrent.atomic.LongAdder; public class CounterDemo { public static void main(String[] args) { // 初始化 LongAdder counter = new LongAdder(); // 累加操作（线程安全） counter.add(10); // 增加指定数值 counter.increment(); // +1（等价于 add(1)） counter.decrement(); // -1 // 获取当前总值（注意：非原子快照） long total = counter.sum(); System.out.println("当前计数: " + total); // 输出: 当前计数: 10 // 重置计数器（谨慎使用！可能导致数据丢失） counter.reset(); System.out.println("重置后: " + counter.sum()); // 输出: 重置后: 0 } } ``` #### 2. 复合操作 ```java // 结合 Lambda 表达式统计符合条件的数据 LongAdder validCount = new LongAdder(); List<String> dataList = Arrays.asList("A", "B", "C", "D"); dataList.parallelStream().forEach(item -> { if (isValid(item)) { // 假设 isValid 是校验函数 validCount.increment(); } }); System.out.println("有效数据量: " + validCount.sum()); ``` --- ### 三、底层原理（分段 CAS 机制） #### 核心结构 1. **base 变量**：基础值，无竞争时直接累加 2. **Cell[] 数组**：当线程竞争时，为每个线程分配独立的 Cell 进行累加 #### 工作流程 1. **无竞争时**：直接通过 CAS 更新 `base` 值 2. **检测到竞争**： - 为当前线程分配一个 Cell（通过线程哈希值映射到数组下标） - 在 Cell 内部进行 CAS 累加 3. **最终求和**：`sum() = base + ΣCell[i]` #### 源码关键逻辑（简化版） ```java public void add(long x) { Cell[] cs; long b, v; int m; Cell c; if ((cs = cells) != null || // 1. 如果已存在 Cell 数组 !casBase(b = base, b + x)) { // 2. 尝试直接更新 base 值失败 boolean uncontended = true; if (cs == null || (m = cs.length - 1) < 0 || (c = cs[getProbe() & m]) == null || // 3. 获取当前线程对应的 Cell !(uncontended = c.cas(v = c.value, v + x))) // 4. 尝试更新 Cell 值 longAccumulate(x, null, uncontended); // 5. 竞争激烈时扩容 Cell 数组 } } ``` --- ### 四、适用场景与注意事项 #### 典型使用场景 1. **高并发统计**：如网站实时点击量、API 调用次数 2. **数据分片累加**：分布式任务局部计数汇总 3. **监控指标采集**：QPS、错误次数等非精确统计 #### 注意事项 1. **sum() 的最终一致性**： ```java // 错误用法：连续调用 sum() 可能得到不同结果 if (counter.sum() > 100 && counter.sum() < 200) { ... } // 正确做法：保存临时快照 long snapshot = counter.sum(); if (snapshot > 100 && snapshot < 200) { ... } ``` 2. **内存消耗**：Cell 数组默认最大扩容到 CPU 核数，可能占用更多内存 3. **重置风险**：`reset()` 会清空所有 Cell 和 base 值，需确保业务允许 --- ### 五、性能测试对比 #### 测试代码 ```java // 对比 AtomicLong 和 LongAdder 的吞吐量 public class Benchmark { static final int THREADS = 100; static final int CYCLES = 100_000; public static void main(String[] args) throws Exception { test(new AtomicLong(), "AtomicLong"); test(new LongAdder(), "LongAdder"); } static void test(Object counter, String name) throws Exception { long start = System.currentTimeMillis(); ExecutorService pool = Executors.newFixedThreadPool(THREADS); for (int i = 0; i < THREADS; i++) { pool.submit(() -> { for (int j = 0; j < CYCLES; j++) { if (counter instanceof AtomicLong) { ((AtomicLong) counter).incrementAndGet(); } else { ((LongAdder) counter).increment(); } } }); } pool.shutdown(); pool.awaitTermination(1, TimeUnit.HOURS); System.out.printf("%s 耗时: %dms%n", name, System.currentTimeMillis() - start); } } ``` #### 典型结果（8核 CPU） | 计数器类型 | 100线程竞争耗时 | |-------------|----------------| | AtomicLong | 4200 ms | | LongAdder | 680 ms | --- ### 六、扩展方案 1. **DoubleAdder**：用于浮点数累加 2. **LongAccumulator**：支持自定义累加规则（如取最大值） ```java // 统计最大值 LongAccumulator maxVal = new LongAccumulator(Long::max, Long.MIN_VALUE); maxVal.accumulate(10); // 当前最大值 10 maxVal.accumulate(5); // 仍为 10 maxVal.accumulate(15); // 更新为 15 ``` --- ### 总结 **使用场景决策树**： ``` 是否需要高并发写入？ ├─ 否 → 使用 AtomicLong（简单精确） └─ 是 → 是否需要实时精确读取？ ├─ 是 → 考虑锁或其他同步机制 └─ 否 → 使用 LongAdder（高性能最终一致） ```