并发编程概述

// =============================
// 【并发示例】多线程在单核上交替执行
// =============================
public class ConcurrencyDemo {
    public static void main(String[] args) {
        // 创建线程 1，执行任务 A
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                // 打印当前线程名和迭代次数
                System.out.println(Thread.currentThread().getName() + " - Task A: " + i);
            }
        }, "Thread-A"); // 给线程命名为 Thread-A
 
        // 创建线程 2，执行任务 B
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                // 打印当前线程名和迭代次数
                System.out.println(Thread.currentThread().getName() + " - Task B: " + i);
            }
        }, "Thread-B"); // 给线程命名为 Thread-B
 
        // 启动两个线程，由 OS 调度器决定如何分配时间片
        // 即使在单核 CPU 上，两个线程也会"并发"执行
        t1.start();
        t2.start();
    }
}

// =============================
// 【并行示例】使用 parallelStream 显式利用多核
// =============================
import java.util.Arrays;
import java.util.List;
 
public class ParallelismDemo {
    public static void main(String[] args) {
        // 准备一个包含大量元素的列表
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 
        // parallelStream() 会利用 ForkJoinPool.commonPool()
        // 将元素分片 (split) 后分配到多个 CPU 核心上并行处理
        long sum = numbers.parallelStream()
                .mapToLong(n -> {
                    // 打印当前处理线程，观察不同核心的参与情况
                    System.out.println("Processing " + n + " on " + Thread.currentThread().getName());
                    return n * n; // 计算平方
                })
                .sum(); // 汇总结果
 
        // 输出最终结果
        System.out.println("Sum of squares: " + sum); // 385
    }
}

单线程执行时间线 (Single-threaded Timeline)
═══════════════════════════════════════════════════════════════
时间 →  |  CPU计算  |████ 等待数据库 ████|  CPU计算  |████ 等待网络 ████|
        |  (5ms)   |     (200ms)       |  (3ms)   |     (150ms)      |
═══════════════════════════════════════════════════════════════
总耗时 = 5 + 200 + 3 + 150 = 358ms
CPU实际工作时间 = 8ms
CPU利用率 = 8 / 358 ≈ 2.2%   ← 极度浪费！

多线程执行时间线 (Multi-threaded Timeline)
═══════════════════════════════════════════════════════════════
线程1: |CPU计算| ████ 等待数据库 ████ |CPU计算|
线程2:        |CPU计算|████ 等待网络 ████|       |CPU计算|
线程3:               |CPU计算|████ 等待文件 ████|        |CPU计算|
─────────────────────────────────────────────────────
CPU:   | T1  | T2   | T3   |  T1  | T2   |  T3  |   ← CPU几乎没有空闲
═══════════════════════════════════════════════════════════════

import java.util.concurrent.*;
import java.util.List;
 
public class CpuUtilizationDemo {
 
    // 模拟一次 I/O 操作：真正的计算极少，大部分时间在"等待"
    static String simulateIOTask(String taskName) {
        try {
            System.out.println(taskName + " 开始执行, 线程: " + Thread.currentThread().getName());
            Thread.sleep(200); // 模拟 200ms 的 I/O 等待（如数据库查询）
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断标志
        }
        return taskName + " 完成"; // 返回处理结果
    }
 
    public static void main(String[] args) throws Exception {
 
        // ========== 串行执行 ==========
        long start = System.currentTimeMillis(); // 记录起始时间
        for (int i = 1; i <= 5; i++) {           // 依次执行 5 个任务
            simulateIOTask("串行任务-" + i);      // 每个任务阻塞 200ms
        }
        long serialTime = System.currentTimeMillis() - start; // 计算串行总耗时
        System.out.println("串行总耗时: " + serialTime + "ms");
        // 预期输出: ~1000ms (5 × 200ms)
 
        // ========== 并发执行 ==========
        ExecutorService pool = Executors.newFixedThreadPool(5); // 创建含 5 个线程的线程池
        start = System.currentTimeMillis();                     // 重置起始时间
 
        List<Future<String>> futures = new java.util.ArrayList<>(); // 用于收集异步结果
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;                                   // lambda 中需要 effectively final 变量
            futures.add(pool.submit(                                // 提交任务到线程池
                () -> simulateIOTask("并发任务-" + taskId)           // 每个任务在独立线程中执行
            ));
        }
 
        for (Future<String> f : futures) { // 等待所有任务完成
            f.get();                        // 阻塞直到该任务返回结果
        }
 
        long concurrentTime = System.currentTimeMillis() - start; // 计算并发总耗时
        System.out.println("并发总耗时: " + concurrentTime + "ms");
        // 预期输出: ~200ms (所有任务并行等待，几乎同时完成)
 
        pool.shutdown(); // 关闭线程池，释放资源
    }
}

          1
S = ─────────────────
    (1 - P) + P / N
 
S = 理论加速比 (Speedup)
P = 可并行化的比例 (Parallel fraction)
N = 处理器/线程数量
(1 - P) = 必须串行执行的比例

import javax.swing.*;
import java.awt.*;
 
public class ResponsivenessDemo {
 
    public static void main(String[] args) {
        // 在 EDT 上创建并显示 GUI（Swing 线程安全的标准做法）
        SwingUtilities.invokeLater(() -> createAndShowGUI());
    }
 
    static void createAndShowGUI() {
        JFrame frame = new JFrame("响应性演示");            // 创建主窗口
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置关闭行为
        frame.setLayout(new FlowLayout());                    // 设置简单流式布局
 
        JButton badButton = new JButton("错误示范: 阻塞UI");  // 会冻结界面的按钮
        JButton goodButton = new JButton("正确示范: 后台执行"); // 不会冻结界面的按钮
        JLabel statusLabel = new JLabel("就绪");              // 状态文字标签
        JProgressBar progressBar = new JProgressBar(0, 100);  // 进度条组件
 
        // ========== 错误示范：直接在 EDT 上执行耗时操作 ==========
        badButton.addActionListener(e -> {
            statusLabel.setText("正在处理...(界面将冻结!)");   // 这行甚至不会立即渲染
            try {
                Thread.sleep(5000); // 模拟 5 秒的耗时操作, EDT 被阻塞!
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
            statusLabel.setText("完成");                      // 5 秒后才更新
            // 在这 5 秒内，窗口无法移动、按钮无法点击、界面完全无响应
        });
 
        // ========== 正确示范：使用 SwingWorker 在后台线程执行 ==========
        goodButton.addActionListener(e -> {
            goodButton.setEnabled(false);                     // 禁用按钮防止重复点击
            statusLabel.setText("后台处理中...");               // 立即更新 UI 状态
 
            // SwingWorker 是 Swing 提供的后台任务工具
            // 泛型参数: <最终结果类型, 中间进度类型>
            new SwingWorker<String, Integer>() {
 
                @Override
                protected String doInBackground() throws Exception {
                    // 此方法在 后台工作线程 中执行，不阻塞 EDT
                    for (int i = 0; i <= 100; i += 10) {
                        Thread.sleep(500);  // 模拟分段耗时工作
                        publish(i);          // 发布中间进度值到 EDT
                    }
                    return "处理完毕!";       // 返回最终结果
                }
 
                @Override
                protected void process(java.util.List<Integer> chunks) {
                    // 此方法在 EDT 中执行，安全地更新 UI
                    int latestProgress = chunks.get(chunks.size() - 1); // 取最新的进度值
                    progressBar.setValue(latestProgress);                // 更新进度条
                    statusLabel.setText("进度: " + latestProgress + "%"); // 更新状态文字
                }
 
                @Override
                protected void done() {
                    // 后台任务完成后，在 EDT 中执行
                    try {
                        statusLabel.setText(get()); // get() 获取 doInBackground 的返回值
                    } catch (Exception ex) {
                        statusLabel.setText("出错: " + ex.getMessage());
                    }
                    goodButton.setEnabled(true);    // 重新启用按钮
                }
            }.execute(); // 启动 SwingWorker
        });
 
        frame.add(badButton);                     // 添加组件到窗口
        frame.add(goodButton);
        frame.add(statusLabel);
        frame.add(progressBar);
        frame.setSize(500, 150);                  // 设置窗口大小
        frame.setVisible(true);                   // 显示窗口
    }
}

进程模型 vs 线程模型的内存布局对比
 
┌──────────────────────────────────────────────────────────────┐
│                      进程模型 (Process)                       │
│                                                              │
│  ┌─────────────────────┐     ┌─────────────────────┐        │
│  │      Process A      │     │      Process B      │        │
│  │  ┌───────────────┐  │     │  ┌───────────────┐  │        │
│  │  │   Code 副本    │  │     │  │   Code 副本    │  │        │
│  │  ├───────────────┤  │     │  ├───────────────┤  │        │
│  │  │   Heap 独立    │  │     │  │   Heap 独立    │  │        │
│  │  ├───────────────┤  │     │  ├───────────────┤  │        │
│  │  │   Stack       │  │     │  │   Stack       │  │        │
│  │  └───────────────┘  │     │  └───────────────┘  │        │
│  └─────────────────────┘     └─────────────────────┘        │
│                                                              │
│  → 内存完全隔离，数据交换需 IPC (管道/Socket/共享内存)          │
│  → 创建/销毁开销大，上下文切换成本高                            │
└──────────────────────────────────────────────────────────────┘
 
┌──────────────────────────────────────────────────────────────┐
│                      线程模型 (Thread)                        │
│                                                              │
│  ┌──────────────────────────────────────────────┐           │
│  │              Process (JVM)                    │           │
│  │  ┌──────────────────────────────────────┐    │           │
│  │  │          共享区域 (Shared)             │    │           │
│  │  │  Code Segment / Heap / 静态变量       │    │           │
│  │  └──────────────────────────────────────┘    │           │
│  │       ↑            ↑            ↑            │           │
│  │  ┌────┴───┐   ┌────┴───┐   ┌────┴───┐       │           │
│  │  │Thread A│   │Thread B│   │Thread C│       │           │
│  │  │ Stack  │   │ Stack  │   │ Stack  │       │           │
│  │  └────────┘   └────────┘   └────────┘       │           │
│  └──────────────────────────────────────────────┘           │
│                                                              │
│  → Heap/代码/静态变量共享，仅 Stack 独立                       │
│  → 创建/销毁开销小，上下文切换更快                              │
└──────────────────────────────────────────────────────────────┘

import java.util.concurrent.*;
import java.util.Map;
 
public class ResourceSharingDemo {
 
    // 所有线程共享同一个 ConcurrentHashMap 实例
    // ConcurrentHashMap 是 Java 提供的线程安全的高性能哈希表
    private static final Map<String, Integer> sharedCache = new ConcurrentHashMap<>();
 
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(4); // 创建 4 个工作线程
 
        // ===== 生产者任务：多个线程并发写入共享缓存 =====
        for (int i = 0; i < 4; i++) {
            final int writerId = i;                            // 捕获循环变量
            pool.submit(() -> {
                for (int j = 0; j < 100; j++) {
                    String key = "key-" + (writerId * 100 + j); // 每个写者写入不同的 key
                    sharedCache.put(key, writerId * 100 + j);   // 直接操作共享对象，无需 IPC
                }
                System.out.println("Writer-" + writerId + " 完成写入 100 条数据");
            });
        }
 
        pool.shutdown();                           // 停止接受新任务
        pool.awaitTermination(10, TimeUnit.SECONDS); // 等待所有任务完成
 
        // 所有线程写入的数据都在同一个 Map 中，无需合并
        System.out.println("共享缓存总条目数: " + sharedCache.size());
        // 输出: 共享缓存总条目数: 400
 
        // 任意线程可以直接读取其他线程写入的数据——零拷贝
        System.out.println("读取 key-250 的值: " + sharedCache.get("key-250"));
    }
}

public class UnsafeCounter {
    private int count = 0; // 共享可变状态
 
    // 这个方法看似简单，实则包含"读-改-写"三步操作
    public void increment() {
        count++; // ⚠️ 非原子操作！等价于: temp = count; temp = temp + 1; count = temp;
    }
 
    public int getCount() {
        return count; // ⚠️ 可能读到"过期"的值
    }
}

1. getfield  count    // 读取当前值到操作数栈 (Read)
2. iconst_1           // 将常量 1 压入操作数栈
3. iadd               // 执行加法 (Modify)
4. putfield  count    // 将结果写回字段 (Write)

public class LazyInitRace {
    private ExpensiveObject instance = null; // 共享引用
 
    // ⚠️ 经典的 check-then-act 竞态
    public ExpensiveObject getInstance() {
        if (instance == null) {         // 步骤1: 检查 (Check)
            // ⚠️ 其他线程可能在此刻也通过了 null 检查
            instance = new ExpensiveObject(); // 步骤2: 执行 (Act)
        }
        return instance;
    }
}

// ✅ 使用 AtomicInteger 修复计数器
import java.util.concurrent.atomic.AtomicInteger;
 
public class SafeCounter {
    private final AtomicInteger count = new AtomicInteger(0); // 原子变量
 
    public void increment() {
        count.incrementAndGet(); // ✅ CAS 保证原子性，无需加锁
    }
 
    public int getCount() {
        return count.get(); // ✅ volatile 语义保证可见性
    }
}

public class DeadlockDemo {
    private final Object lockA = new Object(); // 锁A
    private final Object lockB = new Object(); // 锁B
 
    // 线程1: 先拿 lockA，再拿 lockB
    public void method1() {
        synchronized (lockA) {           // ① 获取 lockA
            System.out.println(Thread.currentThread().getName() + " 持有 lockA");
            try { Thread.sleep(100); } catch (InterruptedException e) {} // 模拟耗时操作
            synchronized (lockB) {       // ③ 等待 lockB（被线程2持有）→ 阻塞!
                System.out.println("method1 完成");
            }
        }
    }
 
    // 线程2: 先拿 lockB，再拿 lockA（加锁顺序与线程1相反!）
    public void method2() {
        synchronized (lockB) {           // ② 获取 lockB
            System.out.println(Thread.currentThread().getName() + " 持有 lockB");
            try { Thread.sleep(100); } catch (InterruptedException e) {} // 模拟耗时操作
            synchronized (lockA) {       // ④ 等待 lockA（被线程1持有）→ 阻塞!
                System.out.println("method2 完成");
            }
        }
    }
}

// ✅ 使用 tryLock 超时避免死锁
public boolean transferMoney(Account from, Account to, int amount) throws InterruptedException {
    long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(10); // 设置10秒超时
    while (true) {
        if (from.lock.tryLock()) {             // 尝试获取第一把锁
            try {
                if (to.lock.tryLock()) {       // 尝试获取第二把锁
                    try {
                        from.debit(amount);    // 两把锁都拿到了，执行转账
                        to.credit(amount);
                        return true;           // 成功
                    } finally {
                        to.lock.unlock();      // 释放第二把锁
                    }
                }
            } finally {
                from.lock.unlock();            // 释放第一把锁（无论是否拿到第二把）
            }
        }
        if (System.nanoTime() >= deadline) {   // 超时检查
            return false;                      // 超时放弃，避免永久阻塞
        }
        Thread.sleep(1);                       // 短暂退避后重试
    }
}

// ⚠️ 活锁示例：两个线程不断"礼让"，永远无法完成
public class LivelockDemo {
    static class Worker {
        private boolean active = true; // 标记是否活跃
 
        // 两个 Worker 互相"让步"
        public synchronized void work(Worker other) {
            while (active) {
                if (other.active) {
                    System.out.println(Thread.currentThread().getName() + ": 对方还在忙，我先让一下");
                    // ⚠️ 没有随机退避, 两个线程永远同步地"让步"
                    continue; // 再次循环检查 → 对方也在循环检查 → 活锁!
                }
                System.out.println(Thread.currentThread().getName() + ": 轮到我工作了");
                active = false; // 完成工作
            }
        }
    }
}

// ✅ 引入随机退避打破活锁
Random random = new Random();
while (conflictDetected) {
    release(myResource);                                     // 释放已持有的资源
    Thread.sleep(random.nextInt(100));                        // 随机等待 0-99ms
    conflictDetected = !tryAcquire(resource1, resource2);    // 重新尝试获取
}

// ✅ 使用公平锁避免饥饿
import java.util.concurrent.locks.ReentrantLock;
 
// fair = true: 等待时间最长的线程优先获得锁
private final ReentrantLock fairLock = new ReentrantLock(true);
 
public void criticalSection() {
    fairLock.lock();     // 公平获取锁（FIFO 顺序）
    try {
        // 临界区代码（尽量短小精悍）
    } finally {
        fairLock.unlock(); // 确保释放锁
    }
}

访问延迟参考（近似值）:
┌────────────────────┬──────────────┐
│     存储层级        │   访问延迟    │
├────────────────────┼──────────────┤
│  L1 Cache          │   ~1 ns      │
│  L2 Cache          │   ~4 ns      │
│  L3 Cache          │   ~12 ns     │
│  主存 (DRAM)       │   ~100 ns    │
│  上下文切换 (含缓存) │   ~5-50 μs   │
└────────────────────┴──────────────┘

// 演示锁竞争对性能的影响
public class SyncOverheadDemo {
    private long count = 0;                          // 非同步版本
    private final Object lock = new Object();
 
    // 版本1: 无锁 → 快但线程不安全
    public void incrementUnsafe() {
        count++;                                     // ⚠️ 非线程安全
    }
 
    // 版本2: 粗粒度锁 → 安全但吞吐量低
    public void incrementCoarseLock() {
        synchronized (lock) {                        // 每次调用都竞争同一把锁
            count++;                                 // 线程安全但串行化严重
        }
    }
 
    // 版本3: 原子变量 → 安全且无阻塞
    private final AtomicLong atomicCount = new AtomicLong(0);
    public void incrementAtomic() {
        atomicCount.incrementAndGet();               // CAS 操作，无需获取锁
    }
}

// ✅ 锁粒度优化示例: 将单一锁拆分为条带锁
public class StripedMap<K, V> {
    private static final int N_LOCKS = 16;                            // 锁的条带数
    private final Node<K, V>[] buckets;                               // 哈希桶数组
    private final Object[] locks;                                     // 条带锁数组
 
    public StripedMap(int capacity) {
        buckets = new Node[capacity];
        locks = new Object[N_LOCKS];
        for (int i = 0; i < N_LOCKS; i++) {
            locks[i] = new Object();                                  // 初始化每把条带锁
        }
    }
 
    private int hash(K key) {
        return Math.abs(key.hashCode() % buckets.length);             // 计算桶索引
    }
 
    public V get(K key) {
        int hash = hash(key);
        synchronized (locks[hash % N_LOCKS]) {                        // 只锁定对应的条带
            // 在该桶内查找 key...                                     // 不同条带的操作完全并行
            return null; // 简化
        }
    }
}

public class BankAccount {
    private int balance = 100;
 
    public void transferOut(int amount) {
        if (balance >= amount) {      // 检查余额
            Thread.sleep(10);          // 模拟处理延迟
            balance -= amount;         // 扣款
        }
    }
}