⚡ 并发编程基础

什么是并发编程

并发编程（Concurrent Programming）是指在同一时间段内执行多个任务的编程方式。在现代计算机系统中，并发编程已经成为提高程序性能和响应能力的重要手段。

并发编程的应用场景

并发编程的优势

• 提高性能：充分利用多核CPU的计算能力
• 改善响应性：避免程序因长时间操作而卡顿
• 增强吞吐量：同时处理更多的任务和请求
• 资源利用率：更好地利用系统资源

并发 vs 并行

并发（Concurrency）和并行（Parallelism）是两个容易混淆的概念，理解它们的区别对于掌握并发编程至关重要。

Java内存模型(JMM)

Java内存模型（Java Memory Model，JMM）定义了Java程序中各种变量的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

内存模型结构

内存交互操作

JMM定义了8种内存交互操作，用于控制主内存与工作内存之间的数据传输：

• lock（锁定）：作用于主内存变量，标识变量为线程独占
• unlock（解锁）：作用于主内存变量，释放锁定状态
• read（读取）：从主内存读取变量值到工作内存
• load（载入）：将read的值放入工作内存的变量副本
• use（使用）：将工作内存变量值传递给执行引擎
• assign（赋值）：将执行引擎的值赋给工作内存变量
• store（存储）：将工作内存变量值传送到主内存
• write（写入）：将store的值写入主内存变量

线程安全问题

当多个线程同时访问共享资源时，如果没有适当的同步机制，就可能出现线程安全问题。这些问题的根源在于并发访问共享数据时的竞态条件。

经典案例：不安全的计数器

public class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++; // 这不是原子操作！
    }
    
    public int getCount() {
        return count;
    }
    
    public static void main(String[] args) throws InterruptedException {
        UnsafeCounter counter = new UnsafeCounter();
        
        // 创建1000个线程，每个线程执行1000次increment
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }
        
        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }
        
        // 期望结果：1000000，实际结果：可能小于1000000
        System.out.println("最终计数: " + counter.getCount());
    }
}

常见的线程安全问题

可见性、原子性、有序性

并发编程中的三大特性是理解线程安全问题的关键。Java内存模型正是围绕这三个特性来设计的。

public class VisibilityDemo {
    private boolean flag = false;
    
    public void writer() {
        flag = true; // 线程1修改
    }
    
    public void reader() {
        while (!flag) {
            // 线程2可能永远看不到flag的修改
        }
        System.out.println("Flag is true!");
    }
}

public class AtomicityDemo {
    private int count = 0;
    
    public void increment() {
        // 非原子操作：读取 -> 修改 -> 写入
        count = count + 1;
    }
    
    // 使用AtomicInteger保证原子性
    private AtomicInteger atomicCount = new AtomicInteger(0);
    
    public void atomicIncrement() {
        atomicCount.incrementAndGet(); // 原子操作
    }
}

public class OrderingDemo {
    private int a = 0;
    private boolean flag = false;
    
    public void writer() {
        a = 1;          // 操作1
        flag = true;    // 操作2
        // 可能被重排序为：flag = true; a = 1;
    }
    
    public void reader() {
        if (flag) {     // 操作3
            int i = a;  // 操作4，可能读到a=0
        }
    }
}