CAS

HashMap的线程安全问题 Map<String, String> map = new HashMap<>(); // 多线程并发put map.put("key1", "value1"); // 线程1 map.put("key2", "value2"); // 线程2 // 问题1：数据丢失 // 问题2：死循环（JDK 7） // 问题3：数据覆盖 三种解决方案： // 方案1：Hashtable（废弃） Map<String, String> map = new Hashtable<>(); // synchronized，性能差 // 方案2：Collections.synchronizedMap Map<String, String> map = Collections.synchronizedMap(new HashMap<>()); // 性能差 // 方案3：ConcurrentHashMap（推荐） Map<String, String> map = new ConcurrentHashMap<>(); // 高性能 JDK 7实现：分段锁 核心思想：将Map分成多个Segment，每个Segment独立加锁 ConcurrentHashMap ├─ Segment[0] (ReentrantLock) │ ├─ HashEntry[0] │ ├─ HashEntry[1] │ └─ ... ├─ Segment[1] (ReentrantLock) │ ├─ HashEntry[0] │ └─ ... └─ ... 优点：降低锁粒度，提高并发度 缺点： ...

引言：原子类的秘密武器 在上一篇文章中，我们学习了AtomicInteger等原子类，它们的核心就是CAS操作： public final int incrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, 1) + 1; } // Unsafe中的实现 public final int getAndAddInt(Object o, long offset, int delta) { int v; do { v = getIntVolatile(o, offset); // 读取当前值 } while (!compareAndSwapInt(o, offset, v, v + delta)); // CAS更新 return v; } 三个核心问题： CAS是如何实现的？（底层原理） CAS有什么问题？（ABA、自旋、单变量） 如何解决这些问题？（AtomicStampedReference等） 本篇文章将深入CAS算法的每个细节。 一、CAS算法的原理 1.1 CAS的定义 CAS（Compare-And-Swap）：比较并交换 boolean CAS(内存地址V, 期望值A, 新值B) { if (V的值 == A) { V的值 = B; return true; // 更新成功 } else { return false; // 更新失败 } } 关键特性： 原子操作：整个比较和交换过程不可分割 硬件支持：由CPU指令保证原子性 无锁：不需要加锁，避免线程阻塞 1.2 CAS的工作流程 示例：两个线程同时执行count++ ...

引言：volatile不能保证原子性 回顾之前讲过的例子： public class Counter { private volatile int count = 0; public void increment() { count++; // 不是原子操作！ } } 问题： count++; // 实际上是3个操作： // 1. temp = count (读) // 2. temp = temp + 1 (修改) // 3. count = temp (写) // 多线程执行时可能丢失更新 解决方案1：synchronized public synchronized void increment() { count++; // 原子操作 } // 缺点：性能开销大 解决方案2：原子类 private AtomicInteger count = new AtomicInteger(0); public void increment() { count.incrementAndGet(); // 原子操作，性能好 } 性能对比： synchronized: 1200ms AtomicInteger: 280ms 性能提升: 4.3倍 本篇文章将深入Java原子类的实现原理和使用方法。 ...

引子：一个计数器的性能优化之路 在前两篇文章中，我们学习了synchronized和Lock来保证线程安全。但是，锁总是有性能开销的。有没有不用锁就能保证线程安全的方法？答案是：CAS（Compare-And-Swap）+ 原子类。 场景：网站访问计数器 /** * 方案1：使用synchronized（加锁） */ public class SynchronizedCounter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } /** * 方案2：使用AtomicInteger（无锁） */ public class AtomicCounter { private AtomicInteger count = new AtomicInteger(0); public void increment() { count.incrementAndGet(); // 无锁，基于CAS } public int getCount() { return count.get(); } } // 性能对比测试 public class CounterBenchmark { private static final int THREAD_COUNT = 100; private static final int ITERATIONS = 10000; public static void main(String[] args) throws InterruptedException { // 测试synchronized版本 SynchronizedCounter syncCounter = new SynchronizedCounter(); long syncTime = testCounter(() -> syncCounter.increment()); System.out.println("Synchronized耗时：" + syncTime + "ms"); // 测试AtomicInteger版本 AtomicCounter atomicCounter = new AtomicCounter(); long atomicTime = testCounter(() -> atomicCounter.increment()); System.out.println("AtomicInteger耗时：" + atomicTime + "ms"); System.out.println("性能提升：" + (syncTime * 100.0 / atomicTime - 100) + "%"); } private static long testCounter(Runnable task) throws InterruptedException { Thread[] threads = new Thread[THREAD_COUNT]; long start = System.currentTimeMillis(); for (int i = 0; i < THREAD_COUNT; i++) { threads[i] = new Thread(() -> { for (int j = 0; j < ITERATIONS; j++) { task.run(); } }); } for (Thread t : threads) t.start(); for (Thread t : threads) t.join(); return System.currentTimeMillis() - start; } } /* 执行结果（JDK 8, 4核CPU）： Synchronized耗时：856ms AtomicInteger耗时：342ms 性能提升：150% 为什么AtomicInteger更快？ 1. 无锁，避免线程阻塞和上下文切换 2. 基于CPU的CAS指令，硬件级支持 3. 自旋重试，适合竞争不激烈的场景 但是，AtomicInteger不是万能的： ├─ 竞争激烈时，自旋会浪费CPU ├─ 不适合复杂的原子操作 └─ 需要理解CAS的原理和限制 */ 本文将深入探讨CAS的原理、Atomic类的实现、以及常用的并发工具类。 ...