【并发编程】一文帮你搞懂并发编程常见概念-计算机架构去理解

原子操作与并发控制详解

目录

• 1. 原子操作基础

  • 1.1 原子操作定义
  • 1.2 原子操作的重要性
  • 1.3 原子操作的应用场景

• 2. 处理器实现原子操作

  • 2.1 使用总线锁保证原子性
    • 2.1.1 总线锁的定义
    • 2.1.2 总线锁的工作原理
    • 2.1.3 总线锁的优缺点
  • 2.2 使用缓存锁保证原子性
    • 2.2.1 缓存锁的原理
    • 2.2.2 缓存锁的实现方式
    • 2.2.3 缓存锁的优点和限制
    • 2.2.4 缓存锁与总线锁的对比

• 3. 缓存行与内存架构

  • 3.1 缓存行的定义
  • 3.2 主流处理器的缓存行大小
  • 3.3 缓存行大小的影响因素
  • 3.4 缓存行对性能的影响
  • 3.5 优化程序以利用缓存行

• 4. MESI缓存一致性协议

  • 4.1 为什么需要缓存一致性协议
  • 4.2 MESI状态详解
  • 4.3 MESI状态转换
  • 4.4 MESI协议的优化与扩展
  • 4.5 实际应用示例

• 5. Java中的原子操作实现

  • 5.1 Java内存模型(JMM)
  • 5.2 原子变量类
  • 5.3 CAS(比较并交换)操作
  • 5.4 ABA问题及解决方案

• 6. 实际应用与最佳实践

  • 6.1 无锁编程技术
  • 6.2 性能调优技巧
  • 6.3 伪共享问题的解决
  • 6.4 实际案例分析

• 7. 总结与展望

  • 7.1 原子操作技术的发展趋势
  • 7.2 新型硬件架构对原子操作的影响

1. 原子操作基础

1.1 原子操作定义

原子（atomic）本意是"不能被进一步分割的最小粒子"，而原子操作（atomic operation）意为"不可被中断的一个或一系列操作"。在计算机科学中，原子操作是指在执行过程中不会被任何其他操作打断的操作，它要么完全执行成功，要么完全不执行，不存在部分执行的状态。

1.2 原子操作的重要性

在多线程环境中，原子操作能确保共享数据的一致性和完整性。没有原子操作，多个线程同时修改共享变量可能导致数据竞争和不一致问题。

1.3 原子操作的应用场景

• 多线程计数器实现
• 并发锁机制
• 无锁数据结构
• 共享资源访问控制

2. 处理器实现原子操作

2.1 使用总线锁保证原子性

2.1.1 总线锁的定义

总线锁（Bus Lock）是一种用于保证多处理器系统中共享资源访问原子性的方法。它通过锁住处理器总线，确保某些特定的操作在多个处理器之间以原子方式执行，从而避免数据竞争或一致性问题。

2.1.2 总线锁的工作原理

1. 锁住总线：当处理器执行一条需要总线锁的指令时，处理器会通过硬件机制发出一个LOCK信号。
2. 指令执行：在锁住总线的状态下，处理器完成指令的执行，确保操作是原子的。
3. 释放总线：指令执行完成后，LOCK信号被释放，总线可以重新被其他处理器或设备访问。

在x86架构中，总线锁通常由带有LOCK前缀的指令触发，如：

LOCK ADD [shared_variable], 1

2.1.3 总线锁的优缺点

优点：

• 保证原子性：通过锁住总线，确保操作在多个处理器之间是原子的。
• 简单可靠：硬件级的机制，无需复杂的软件逻辑。

缺点：

• 性能开销高：锁住总线会使其他处理器无法访问内存，严重影响系统的并行性。
• 影响缓存一致性：总线锁会导致缓存失效，其他处理器的缓存中可能存储了无效的数据。

2.2 使用缓存锁保证原子性

2.2.1 缓存锁的原理

缓存锁的核心思想是锁定处理器的缓存行（Cache Line）来实现原子操作，而不是锁住整个总线。如果目标内存地址已经被缓存，处理器会尝试锁定这部分缓存行，依赖于缓存一致性协议（如MESI协议）让其他处理器感知到缓存行被锁定。

2.2.2 缓存锁的实现方式

在x86架构中，缓存锁通常通过带有LOCK前缀的指令实现，但只有在以下条件满足时才会触发缓存锁：

• 操作的内存地址已经缓存
• 操作不跨缓存行边界
• 处理器支持缓存一致性协议

缓存锁的工作流程：

1. 内存地址加载到缓存行
2. 缓存锁生效，标记缓存行为"锁定"状态
3. 缓存一致性协议阻止其他处理器访问锁定的缓存行
4. 操作完成后解锁，缓存行恢复正常状态

2.2.3 缓存锁的优点和限制

优点：

• 减少总线争用：仅锁定本地处理器的缓存行，不锁住整个系统总线
• 提高并行性：允许多个处理器同时对不同的缓存行进行操作
• 降低性能开销：通过缓存一致性协议限制操作范围，减少性能损失

限制：

• 仅适用于单个缓存行：如果操作跨越多个缓存行，需要退回到总线锁
• 依赖缓存一致性协议：需要硬件支持
• 受缓存行伪共享问题影响：可能导致性能下降

2.2.4 缓存锁与总线锁的对比

特性	缓存锁	总线锁
锁定范围	处理器缓存行	整个系统总线
性能	高性能，减少对总线的争用	性能较低，锁住总线影响并行性
使用条件	单个缓存行内的内存操作	跨缓存行或未缓存的内存操作
依赖机制	缓存一致性协议（如MESI协议）	无需缓存一致性协议

3. 缓存行与内存架构

3.1 缓存行的定义

缓存行（Cache Line）是处理器缓存中存储数据的最小单位，是一个固定大小的连续内存块，用于在主存和处理器缓存之间传输数据。

3.2 主流处理器的缓存行大小

不同处理器架构的缓存行大小可能有所不同，但现代主流处理器的缓存行大小为64字节：

处理器架构	缓存行大小
Intel x86/x64	64字节
AMD x86/x64	64字节
ARM（部分架构）	64字节
IBM PowerPC	128字节
MIPS	32-64字节

3.3 缓存行大小的影响因素

1. 折中设计：缓存行过小会导致频繁访问主存，缓存行过大会浪费缓存空间
2. 内存带宽利用率：现代内存总线通常以64字节为基本传输单位
3. 局部性优化：64字节的缓存行可以适应大多数程序的内存访问模式
4. 硬件复杂度：更大的缓存行会增加硬件复杂度

3.4 缓存行对性能的影响

1. 空间局部性：程序对连续地址访问的效率受缓存行大小影响
2. 伪共享问题：多线程操作同一缓存行中的不同变量会触发缓存一致性协议
3. 缓存一致性开销：缓存行是缓存一致性协议的基本操作单元
4. 内存对齐效率：不对齐的数据可能跨缓存行存储，导致性能下降

3.5 优化程序以利用缓存行

1. 数据对齐：确保数据按缓存行对齐存储，避免跨缓存行访问
2. 减少伪共享：将不同线程使用的变量分布在不同的缓存行中
3. 优化数据访问模式：尽量使用连续内存访问，提升缓存命中率

4. MESI缓存一致性协议

4.1 为什么需要缓存一致性协议

在多核处理器中，每个核心都有自己的私有缓存，这会引发数据一致性问题：

• 多个缓存中存储了同一内存地址的数据时，一个缓存的修改可能导致其他缓存数据过时
• 如果每次修改都通知所有处理器并更新内存，会严重影响性能

缓存一致性协议通过定义规则来确保多处理器系统中缓存数据的一致性。

4.2 MESI状态详解

MESI协议定义了缓存行的四种状态：

1. Modified（修改）：

   • 缓存行数据已被修改，与主存不一致
   • 只有当前缓存拥有这份数据
   • 写操作可直接进行，无需通知其他处理器

2. Exclusive（独占）：

   • 缓存行数据与主存一致，且只有当前处理器缓存了此数据
   • 读写操作可直接进行，写操作会将状态转为Modified

3. Shared（共享）：

   • 缓存行数据与主存一致，且可能存在于多个处理器的缓存中
   • 读操作可直接进行，写操作需先通知其他处理器将该缓存行设为Invalid

4. Invalid（无效）：

   • 缓存行数据已失效，不能被访问
   • 需要从其他缓存或主存重新加载数据

4.3 MESI状态转换

MESI协议通过缓存一致性消息在不同状态之间进行转换：

1. 从主存加载数据：

   • Invalid → Exclusive：当没有其他处理器缓存此数据时
   • Invalid → Shared：当其他处理器已缓存此数据时

2. 读取操作引起的转换：

   • 无状态变化：如果当前状态为Modified、Exclusive或Shared

3. 写入操作引起的转换：

   • Shared → Modified：通知其他处理器将该缓存行设为Invalid
   • Exclusive → Modified：直接写入，无需通知
   • Invalid → Modified：先加载数据，再写入

4. 其他处理器访问引起的转换：

   • Modified → Shared：其他处理器读取，需将数据写回主存
   • Exclusive → Shared：其他处理器读取
   • Modified/Exclusive/Shared → Invalid：其他处理器写入

4.4 MESI协议的优化与扩展

基于MESI协议的高级优化：

1. MOESI协议：

   • 增加Owned状态，表示数据已修改但可与其他处理器共享
   • 减少写回主存的次数，提高性能

2. MESIF协议：

   • 增加Forward状态，优化数据从共享缓存中转发的过程
   • 减少主存访问，提高数据共享效率

3. 伪共享优化：

   • 通过填充避免多线程操作同一缓存行中的不同变量
   • 减少缓存一致性协议带来的性能损耗

4.5 实际应用示例

假设两个线程分别运行在不同处理器核心上，操作一个共享变量：

// 线程A（核心1）
x = 10;  // 写操作

// 线程B（核心2）
y = x;   // 读操作

MESI状态转换过程：

1. 初始状态：两个核心缓存中x都为Shared状态
2. 线程A写入：
   • 核心1将x状态从Shared→Modified
   • 核心2中x变为Invalid
3. 线程B读取：
   • 核心2请求读取x
   • 核心1将x写回主存，状态从Modified→Shared
   • 核心2从主存加载x，状态设为Shared

5. Java中的原子操作实现

5.1 Java内存模型(JMM)

Java内存模型（JMM）规定了Java虚拟机如何与计算机内存进行交互，定义了线程之间如何通过内存进行通信，以及什么情况下共享变量的更新对其他线程可见。

JMM的主要特性：

• 原子性：保证操作不会被线程调度机制打断
• 可见性：保证变量修改对其他线程可见
• 有序性：保证指令执行顺序符合程序逻辑

5.2 原子变量类

Java提供了java.util.concurrent.atomic包，包含各种原子变量类：

1. 基本类型：

   • AtomicInteger、AtomicLong、AtomicBoolean
   • 提供原子性的自增、自减、比较并设置等操作

2. 引用类型：

   • AtomicReference、AtomicStampedReference、AtomicMarkableReference
   • 处理引用类型的原子操作，后两者可解决ABA问题

3. 数组类型：

   • AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
   • 对数组元素进行原子操作

4. 属性更新器：

   • AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
   • 对对象的volatile字段进行原子更新

5.3 CAS(比较并交换)操作

比较并交换（Compare-And-Swap，CAS）是实现原子操作的核心技术：

1. CAS原理：

   • 原子地比较内存位置的值与预期值
   • 如果相等，则将该内存位置的值修改为新值
   • 如果不相等，则操作失败，返回当前值

2. Java中的CAS：

   public final boolean compareAndSet(int expect, int update) {
       return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
   }
   

3. 底层实现：

   • Java的CAS操作由native方法实现
   • 在x86架构上，通常使用LOCK CMPXCHG指令
   • 指令会触发处理器的缓存锁或总线锁

5.4 ABA问题及解决方案

ABA问题是指在CAS操作中，如果一个值原来是A，变成了B，又变回了A，使用CAS检查时会误认为它没有被修改过。

解决方案：

1. 版本号/时间戳：

   • 使用AtomicStampedReference，在更新引用时附带版本号

   AtomicStampedReference<Integer> atomicRef = new AtomicStampedReference<>(100, 0);
   // 获取当前版本号
   int stamp = atomicRef.getStamp();
   // 进行CAS操作时同时检查版本号
   atomicRef.compareAndSet(100, 101, stamp, stamp + 1);
   

2. 标记位：

   • 使用AtomicMarkableReference，只关心引用是否被修改过

   AtomicMarkableReference<Integer> atomicRef = new AtomicMarkableReference<>(100, false);
   // 进行CAS操作时同时检查标记
   atomicRef.compareAndSet(100, 101, false, true);
   

6. 实际应用与最佳实践

6.1 无锁编程技术

无锁编程是一种并发编程方法，不使用传统的锁机制而是利用原子操作：

1. 优势：

   • 避免锁竞争和线程切换开销
   • 减少死锁风险
   • 提高系统吞吐量

2. 常见技术：

   • 使用CAS实现无锁数据结构
   • 使用原子变量类进行并发控制
   • 实现无阻塞算法

3. 经典例子：无锁队列实现

   public void enqueue(T item) {
       Node<T> newNode = new Node<>(item);
       while (true) {
           Node<T> tail = this.tail.get();
           Node<T> next = tail.next.get();
           if (tail == this.tail.get()) {
               if (next == null) {
                   if (tail.next.compareAndSet(null, newNode)) {
                       this.tail.compareAndSet(tail, newNode);
                       return;
                   }
               } else {
                   this.tail.compareAndSet(tail, next);
               }
           }
       }
   }
   

6.2 性能调优技巧

优化并发代码的关键技巧：

1. 减少共享：

   • 使用线程本地存储（ThreadLocal）
   • 分片技术减少竞争

2. 合理使用CAS：

   • 避免CAS自旋过度消耗CPU
   • 考虑适当回退策略

3. 批处理：

   • 合并多个操作减少原子操作次数
   • 分批处理大量数据

4. 锁粒度优化：

   • 减小锁的粒度
   • 使用读写锁分离读写操作

6.3 伪共享问题的解决

伪共享是缓存系统中的一个常见性能问题：

1. 伪共享问题：

   • 当多线程操作位于同一缓存行的不同变量时，会频繁触发缓存一致性操作
   • 即使线程操作的是不同变量，由于它们共享缓存行，也会导致性能下降

2. 解决方法：

   • 使用填充（Padding）将变量分散到不同缓存行

   public final class PaddedLong {
       public volatile long value = 0L;
       // 填充以避免伪共享
       public long p1, p2, p3, p4, p5, p6;
   }
   

   • 使用Java 8的@Contended注解（需JVM参数支持）

   @sun.misc.Contended
   public class ContendedLong {
       public volatile long value = 0L;
   }
   

6.4 实际案例分析

高性能计数器实现案例分析：

1. 问题场景：需要在高并发环境中实现一个精确计数器

2. 传统实现：

   public class SynchronizedCounter {
       private long count = 0;
     
       public synchronized void increment() {
           count++;
       }
     
       public synchronized long getCount() {
           return count;
       }
   }
   

   问题：synchronized锁开销大，所有线程争用同一把锁

3. 优化实现：

   public class StripedAtomicCounter {
       private final int concurrencyLevel;
       private final AtomicLong[] counters;
     
       public StripedAtomicCounter(int concurrencyLevel) {
           this.concurrencyLevel = concurrencyLevel;
           counters = new AtomicLong[concurrencyLevel];
           for (int i = 0; i < concurrencyLevel; i++) {
               counters[i] = new AtomicLong();
           }
       }
     
       public void increment() {
           // 分散更新到不同的计数器，减少争用
           int index = (int)((Thread.currentThread().getId() % concurrencyLevel));
           counters[index].incrementAndGet();
       }
     
       public long getCount() {
           long sum = 0;
           for (AtomicLong counter : counters) {
               sum += counter.get();
           }
           return sum;
       }
   }
   

   优势：分散了线程争用，减少了CAS失败次数，提高了并发性能