多线程基础

线程 = "舞台上的演员"

• 线程属于某个进程，共享该进程的内存空间
• 每个线程有自己的栈（局部变量）和程序计数器
• 线程间通信简单：直接读写共享变量
• 例子：浏览器同时下载文件、渲染页面、响应用户输入，各是线程

线程=“不卡”的代价

• 线程切换开销远小于进程，适合并发与响应式场景
• 同进程内线程共享堆与方法区，通信零拷贝
• 但共享可变数据必须正确同步，否则结果错乱

// 剧本 = 表演内容（演什么）
Runnable script = () -> {
    System.out.println("表演中...");
};

// 演员 = 表演载体（谁来演）
Thread actor1 = new Thread(script);
Thread actor2 = new Thread(script);

actor1.start(); // 演员1上台表演
actor2.start(); // 演员2上台表演

演员只是被动的表演者，它不"理解"剧本的情节，只是按顺序表演台词。导演决定谁上台，不关心演员在表演什么剧本。

🔍 问题根源

⚡ 为什么会这样？

在计算机中，一个简单的 i++ 操作实际分成三步：

如果线程A在步骤2时，线程B执行了步骤1，两个线程都会基于相同的旧值进行修改！

import java.util.LinkedList;

class BoundedQueue<T> {
    private final LinkedList<T> q = new LinkedList<>();
    private final int cap;
    public BoundedQueue(int cap) { this.cap = cap; }
    
    public synchronized void put(T x) throws InterruptedException {
        while (q.size() == cap) wait(); // 满了就睡，释放锁
        q.add(x);
        // 唤醒所有人（包括厨师和顾客）。
        // 为什么不用 notify()？因为可能错误地唤醒了另一个“厨师”，
        // 而我们需要唤醒“顾客”。notifyAll() 虽然吵醒所有人，但最安全。
        notifyAll(); 
    }
    
    public synchronized T take() throws InterruptedException {
        while (q.isEmpty()) wait(); // 空了就睡，释放锁
        T x = q.removeFirst();
        notifyAll(); // 唤醒所有人
        return x;
    }

    public static void main(String[] args) {
        BoundedQueue<Integer> queue = new BoundedQueue<>(1);
        // 生产者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    queue.put(i);
                    System.out.println("做好了: " + i);
                }
            } catch (InterruptedException e) {}
        }).start();

        // 消费者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    Integer x = queue.take();
                    System.out.println("吃掉了: " + x);
                }
            } catch (InterruptedException e) {}
        }).start();
    }
}

配合 synchronized 使用，完美解决“忙等待”和“死锁”风险。

public class VisibilityDemo {
    // ❌ 缺少 volatile，存在可见性问题
    static boolean running = true;

    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            long i = 0;
            // 子线程可能永远看不到 running 变为 false
            while (running) { 
                i++; 
            }
            System.out.println("Stopped: " + i);
        });
        t.start();
        
        Thread.sleep(100);
        running = false; // 主线程修改状态
        System.out.println("Set running = false");
    }
}

public class VolatileSolution {
    // ✅ 加上 volatile，保证可见性
    static volatile boolean running = true;

    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            while (running) { 
                // 此时每次读取都会去主内存获取最新值
            }
            System.out.println("Thread stopped.");
        });
        t.start();
        
        Thread.sleep(100);
        running = false; // 修改立刻对子线程可见
    }
}

适用场景：状态标志（Flag）、单例模式的双重检查锁定（DCL）。

🚀 JUC 带来的突破

• 线程池框架：ThreadPoolExecutor 自动管理线程
• 高级锁机制：ReentrantLock、ReadWriteLock 提供更灵活控制
• 丰富同步工具：CountDownLatch、CyclicBarrier、Semaphore
• 高性能并发集合：ConcurrentHashMap、BlockingQueue
• 原子操作类：AtomicInteger、AtomicReference 实现无锁编程
• 异步编程革命：CompletableFuture 支持链式调用