Java并发编程：并发与并行核心概念解析

1. 并发与并行：核心概念辨析

在当今多核处理器普及的时代，理解并发与并行的区别是每个Java开发者必须掌握的基础知识。这两个概念经常被混淆，但它们代表着完全不同的执行模型。

**并发（Concurrency）**的本质是任务切换的艺术。想象一位餐厅厨师同时处理多个订单：他先切配菜A的食材，然后翻炒菜B，接着回来调味菜A。虽然同一时刻他只在做一个动作，但通过快速切换，给顾客造成了"同时进行"的错觉。这种模式的关键特点包括：

• 依赖CPU的时间片轮转机制
• 通过上下文切换实现多任务"同时"执行
• 单核CPU也能实现并发
• 主要解决资源利用率问题

典型场景包括：

• Web服务器同时处理多个HTTP请求
• GUI程序响应用户输入的同时进行后台计算
• 批处理系统交替执行多个作业

**并行（Parallelism）**则像是一个交响乐团——不同乐器（CPU核心）真正同时演奏各自的声部。当我们需要处理大规模数据计算时，这种能力显得尤为重要：

• 必须依赖多核CPU或分布式系统
• 各任务真正物理上同时执行
• 主要解决计算吞吐量问题
• 需要任务间具备良好的可分割性

实际工程中常见的并行场景：

• 图像处理中同时计算不同区域像素
• MapReduce框架中的分布式计算
• 科学计算中的矩阵并行运算

理解这个区别的实际意义在于：当我们需要优化系统性能时，首先要明确瓶颈类型。如果是IO密集型任务，并发优化可能更有效；而对于CPU密集型任务，并行化改造往往能带来质的提升。

2. 并发三大特性深度解析

2.1 可见性问题全貌

可见性问题源于现代计算机的存储体系结构。为了弥补CPU与主内存之间的速度鸿沟，现代处理器普遍采用多级缓存架构：

code复制CPU核心 → L1缓存 → L2缓存 → L3缓存 → 主内存

这种架构带来的可见性问题表现为：

1. 写缓冲延迟：CPU写入不会立即刷新到主存
2. 失效队列延迟：其他CPU不会立即收到缓存失效通知
3. 缓存一致性协议：MESI等协议存在实现差异

我们可以通过以下代码观察典型的可见性问题：

java复制class VisibilityProblem {
    boolean ready = false;
    int result = 0;
    
    void writer() {
        result = 42;      // (1)
        ready = true;     // (2)
    }
    
    void reader() {
        while(!ready);    // (3)
        System.out.println(result); // (4)
    }
}

由于指令重排序和缓存不一致，(2)可能先于(1)执行，导致(4)输出0而不是42。这种问题在x86架构下出现概率约为1/1000，而在ARM架构下可能高达1/10。

2.2 有序性本质探究

现代处理器采用乱序执行(Out-of-Order Execution)来提升性能，这种优化在单线程环境下完全透明，但在多线程场景就会暴露问题。重排序主要发生在三个层面：

1. 编译器优化：包括指令调度、循环展开、死代码消除等
2. CPU流水线：通过保留站实现动态调度
3. 内存系统：写缓冲区和无效队列导致内存操作乱序

JMM通过happens-before关系定义了一系列禁止重排序的规则。例如对于volatile变量：

• 写操作前插入StoreStore屏障
• 写操作后插入StoreLoad屏障
• 读操作前插入LoadLoad屏障
• 读操作后插入LoadStore屏障

这些屏障就像交通警察，确保关键操作按照预期顺序执行。

2.3 原子性实战分析

原子性问题最常见的表现就是"竞态条件"。我们来看一个银行转账的典型例子：

java复制class Account {
    private int balance;
    
    void transfer(Account target, int amount) {
        if (this.balance >= amount) {          // (1)
            this.balance -= amount;            // (2)
            target.balance += amount;          // (3)
        }
    }
}

这个简单的转账操作至少存在三种竞态条件：

1. 检查后执行(Check-Then-Act)：(1)检查后余额可能被其他线程修改
2. 读-改-写(Read-Modify-Write)：(2)和(3)不是原子操作
3. 复合操作：整个transfer方法需要原子性保证

解决方案包括：

• synchronized同步块
• java.util.concurrent.atomic包
• 显式锁(ReentrantLock)
• 不可变对象+CAS

3. JMM内存模型详解

3.1 内存交互操作全景

JMM定义的8种原子操作构成了线程通信的基础协议。这些操作的实际硬件实现非常复杂：

特别需要注意的是，x86架构是强内存模型，默认提供较强的顺序一致性保证；而ARM是弱内存模型，需要更多显式内存屏障。

3.2 happens-before规则体系

happens-before关系构成了JMM的理论基础。这个关系具有以下数学特性：

• 自反性：A happens-before A
• 反对称性：如果A hb B且B hb A，则A=B
• 传递性：如果A hb B且B hb C，则A hb C

实际编程中最常用的happens-before规则组合：

1. volatile变量规则+程序顺序规则：

java复制volatile boolean flag = false;
int value = 0;

void writer() {
    value = 42;         // (1)
    flag = true;        // (2)
}

void reader() {
    if (flag) {         // (3)
        print(value);   // (4)
    }
}

这里(1)hb(2)（程序顺序），(2)hb(3)（volatile规则），因此(1)hb(4)。

2. 监视器锁规则+程序顺序规则：

java复制final Object lock = new Object();
int sharedData = 0;

void threadA() {
    synchronized(lock) {
        sharedData = 1;  // (1)
    }                    // (2)
}

void threadB() {
    synchronized(lock) { // (3)
        print(sharedData); // (4)
    }
}

(1)hb(2)（程序顺序），(2)hb(3)（锁规则），因此(1)hb(4)。

4. volatile关键字深度优化

4.1 内存语义实现

volatile的底层实现因平台而异：

• x86：通过LOCK前缀指令实现缓存一致性
• ARM：需要显式内存屏障指令(DMB/DSB/ISB)
• JVM：插入相应的内存屏障

HotSpot虚拟机的具体实现（x86平台）：

cpp复制// 写操作
StoreStoreBarrier();
// 写入volatile变量
*addr = value;
StoreLoadBarrier();

// 读操作
value = *addr;
LoadLoadBarrier();
LoadStoreBarrier();

4.2 使用模式与反模式

正确使用模式：

1. 状态标志位

java复制volatile boolean shutdownRequested;

void shutdown() { shutdownRequested = true; }

void doWork() {
    while(!shutdownRequested) {
        // 执行任务
    }
}

2. 一次性安全发布

java复制class Singleton {
    private volatile static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

典型误用：

1. 误认为volatile能保证原子性

java复制volatile int count = 0;

// 线程不安全！
void increment() {
    count++; 
}

2. 过度使用导致性能下降

java复制// 不需要volatile，String本身不可变
volatile String cache;

void updateCache() {
    cache = loadFromDB(); 
}

5. 有序性优化实践

5.1 指令重排序约束

JMM对重排序的限制可以用以下表格总结：

这个表格的意思是：

• 普通写不能重排序到任意volatile操作之前
• volatile读不能重排序到任何操作之前
• volatile写不能重排序到任何volatile读/写之后

5.2 内存屏障实战

不同处理器架构需要不同的屏障指令：

x86架构：

• StoreStore：空操作(no-op)
• LoadLoad：空操作
• LoadStore：空操作
• StoreLoad："mfence"指令

ARM架构：

• StoreStore："dmb ishst"
• LoadLoad："dmb ishld"
• LoadStore："dmb ish"
• StoreLoad："dmb ish"

Java通过Unsafe类提供底层屏障控制：

java复制// 相当于StoreStore屏障
Unsafe.getUnsafe().storeFence();

// 相当于StoreLoad屏障
Unsafe.getUnsafe().fullFence();

6. 并发编程最佳实践

6.1 可见性保证方案

1. 不可变对象：

java复制@Immutable
class Config {
    final int timeout;
    final String url;
    
    Config(int timeout, String url) {
        this.timeout = timeout;
        this.url = url;
    }
}

2. 安全发布模式：

java复制final Map<String, Data> cache = new ConcurrentHashMap<>();

void publish(String key, Data value) {
    cache.put(key, value);
}

Data get(String key) {
    return cache.get(key);
}

6.2 原子性保证方案

1. 原子变量：

java复制AtomicInteger counter = new AtomicInteger();

void safeIncrement() {
    counter.incrementAndGet();
}

2. 锁优化技巧：

java复制class OptimizedLock {
    private final ReentrantLock lock = new ReentrantLock();
    
    void doSomething() {
        if (lock.tryLock(100, TimeUnit.MILLISECONDS)) {
            try {
                // 临界区
            } finally {
                lock.unlock();
            }
        }
    }
}

6.3 有序性保证方案

1. final字段语义：

java复制class PublishedObject {
    final int x;
    int y;
    
    PublishedObject(int x, int y) {
        this.x = x;  // 保证构造完成后可见
        this.y = y;  // 普通字段不保证
    }
}

2. 静态初始化模式：

java复制class Singleton {
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;  // 利用类加载机制保证线程安全
    }
}

7. 性能考量与权衡

7.1 内存屏障开销测试

通过JMH基准测试不同屏障指令的开销（纳秒/操作）：

7.2 volatile vs synchronized

在实际高并发场景中，合理使用volatile可以减少约60%的锁竞争开销。

8. 常见陷阱与解决方案

8.1 伪共享问题

CPU缓存以缓存行(通常64字节)为单位，当不同线程修改同一缓存行的不同变量时，会导致性能急剧下降。

解决方案：

1. 填充(Padding)：

java复制class ContendedData {
    @sun.misc.Contended
    volatile long value1;
    
    @sun.misc.Contended
    volatile long value2;
}

2. 数组隔离：

java复制class ThreadLocalData {
    volatile long[] values = new long[16]; // 每个线程使用不同索引
}

8.2 安全发布陷阱

以下发布方式不安全：

java复制class UnsafePublication {
    static Resource resource;
    
    static void init() {
        resource = new Resource();  // 可能看到部分构造的对象
    }
}

安全发布方式：

1. 静态初始化器
2. volatile字段
3. final字段
4. 正确构造的ConcurrentHashMap

9. 高级主题：JMM与硬件内存模型

9.1 主流架构差异

9.2 JMM实现策略

HotSpot虚拟机的内存屏障插入策略：

1. 保守策略：为所有volatile访问插入完整屏障
2. 优化策略：基于数据流分析消除冗余屏障
3. 架构适配：根据不同CPU特性调整屏障类型

在x86上，JVM可以省略大部分LoadLoad和StoreStore屏障，因为x86的TSO内存模型已经提供了这些保证。

10. 实战：设计线程安全计数器

10.1 volatile方案

java复制class VolatileCounter {
    private volatile int count = 0;
    
    // 线程不安全！
    public void increment() {
        count++; 
    }
    
    // 线程安全但性能差
    public synchronized void safeIncrement() {
        count++;
    }
}

10.2 CAS方案

java复制class CASCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        int current;
        do {
            current = count.get();
        } while (!count.compareAndSet(current, current + 1));
    }
}

10.3 分段计数方案

java复制class StripedCounter {
    private final AtomicInteger[] counts;
    private static final int NCPU = Runtime.getRuntime().availableProcessors();
    
    public StripedCounter() {
        counts = new AtomicInteger[NCPU];
        for (int i = 0; i < NCPU; i++) {
            counts[i] = new AtomicInteger(0);
        }
    }
    
    public void increment() {
        int id = Thread.currentThread().hashCode() % NCPU;
        counts[id].incrementAndGet();
    }
    
    public int get() {
        int sum = 0;
        for (AtomicInteger c : counts) {
            sum += c.get();
        }
        return sum;
    }
}

性能对比（Ops/ms，8线程）：

在实际工程中，选择哪种方案取决于具体场景：

• 低竞争：CAS
• 高竞争：分段
• 强一致：synchronized
• 统计类：最终一致

理解JMM和并发特性的关键在于平衡安全性与性能。通过合理运用volatile、final、原子变量等工具，结合业务特点选择适当的线程安全策略，才能构建出既正确又高效的并发系统。