Java 并发核心实战：单例、生产者消费者、定时器与线程池详解

实现细节：

1. 通过 synchronized 加锁解决线程安全。
2. 双重检查锁定（Double-Checked Locking），外层 if 减少同步开销。
3. volatile 关键字防止指令重排序，避免半初始化对象被其他线程访问。

特点：按需创建，启动快，资源利用率高。 缺点：实现复杂，若未正确使用同步机制，极易出现线程安全问题。

1.4 懒汉模式中的指令重排序问题

理解 Java 对象初始化流程有助于明白为什么需要 volatile：

1. 内存分配阶段：JVM 在堆内存中为对象分配空间。
2. 对象初始化阶段：执行构造函数，初始化成员变量。
3. 引用赋值阶段：将内存地址赋值给引用变量。

正常顺序：分配 -> 初始化 -> 引用赋值。 指令重排序后：分配 -> 引用赋值 -> 初始化。

若发生重排序，其他线程可能在对象未完成初始化时就获取到引用，导致空指针或异常。volatile 能禁止这种重排序，确保可见性和有序性。

1.5 懒汉/饿汉优缺点对比

2. 生产者/消费者模式

2.1 概述

生产者/消费者模式用于协调多个线程之间的任务分配与数据处理。生产者负责生成数据放入缓冲区，消费者从缓冲区取走数据并处理。二者通过共享队列解耦，互不直接依赖。

核心作用：

• 解耦生产与消费逻辑：降低代码耦合度，提高模块化程度。
• 平衡处理速率差异：缓冲区作为中间层，允许生产者和消费者以不同速度运行，避免互相阻塞。
• 削峰填谷：平滑流量波动，防止瞬时高负载导致系统崩溃。

2.2 实现阻塞队列

为了演示原理，我们手写一个简单的阻塞队列实现：

class MyBlockingQueue {
    private int head = 0;
    private int tail = 0;
    private int useSize = 0;
    private final String[] array;

    public MyBlockingQueue(int capacity) {
        array = new String[capacity];
    }

    // 添加元素
    public synchronized void put(String string) throws InterruptedException {
        while (isFull()) { // 队列满了，等待消费者
            this.wait();
        }
        array[tail] = string;
        tail++;
        tail = (tail + 1) % array.length;
        useSize++;
        this.notify();
    }

    // 删除元素
    public synchronized String take() throws InterruptedException {
        String ret;
        while (useSize <= 0) { // 队列空了，等待生产者
            this.wait();
        }
        ret = array[head];
        head++;
        head = (head + 1) % array.length;
        useSize--;
        this.notify();
        return ret;
    }

    // 判断是否满了
    private boolean isFull() {
        return useSize >= array.length;
    }
}

注意：这里使用了 while 循环而非 if 来判断条件，是为了防止虚假唤醒（Spurious Wakeup）。同时 put 和 take 方法都加了 synchronized，确保临界区安全。

2.3 模拟生产者/消费者

public class Producer_Consumer_Blog {
    public static void main(String[] args) {
        MyBlockingQueue queue = new MyBlockingQueue(1000);

        Thread thread1 = new Thread(() -> {
            int n = 1;
            while (true) {
                try {
                    queue.put(n + "");
                    System.out.println("生产元素 n = " + n);
                    n++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            while (true) {
                try {
                    System.out.println("消费元素 n = " + queue.take());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

3. 定时器

3.1 概述

定时器（Timer）用于在特定时间间隔或指定时间点执行任务，广泛应用于定时调度、延迟操作等场景。它将任务逻辑与时间控制解耦。

核心特点：

• 异步调度：安排任务在未来执行，不阻塞主线程。
• 后台执行：默认使用后台线程，主线程结束不影响任务（除非设置为非守护线程）。
• 简单易用：适合不需要复杂调度的场景。

标准库 Timer 构造方法：

// 1. 默认构造方法
public Timer() {
    this("Timer-" + serialNumber());
}

// 2. 指定线程名字
public Timer(String name) {
    thread.setName(name);
    thread.start();
}

// 3. 指定是否为后台线程
public Timer(boolean isDaemon) {
    this("Timer-" + serialNumber(), isDaemon);
}

// 4. 指定线程名字和是否为后台线程
public Timer(String name, boolean isDaemon) {
    thread.setName(name);
    thread.setDaemon(isDaemon);
    thread.start();
}

常用 schedule 方法：

1. 单次执行：schedule(TimerTask task, Date time)

   Timer timer = new Timer();
   TimerTask task = () -> System.out.println("延迟三秒执行");
   timer.schedule(task, new Date(System.currentTimeMillis() + 1000));
   

2. 周期执行：schedule(TimerTask task, Date firstTime, long period)

   timer.schedule(task, new Date(System.currentTimeMillis() + 1000), 1000);
   

3. 相对延迟单次：schedule(TimerTask task, long delay)

   timer.schedule(task, 3000); // 当前时间延迟 3000ms 后执行
   

4. 相对延迟周期：schedule(TimerTask task, long delay, long period)

   timer.schedule(task, 3000, 3000); // 延迟 3 秒首次执行，之后每 3 秒一次
   

3.2 模拟实现定时器

基于优先级队列（PriorityQueue）可以手动实现一个简单的定时器：

class MyTask implements Comparable<MyTask> {
    private final Runnable runnable;
    private final long time;

    public MyTask(Runnable runnable, long delay) {
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
        return this.time;
    }

    public void run() {
        runnable.run();
    }

    @Override
    public int compareTo(MyTask o) {
        return (int) (this.time - o.time);
    }
}

class MyTime {
    private final PriorityQueue<MyTask> queue = new PriorityQueue<>();

    public void schedule(Runnable runnable, long delay) {
        synchronized (this) {
            MyTask myTask = new MyTask(runnable, delay);
            queue.offer(myTask);
            this.notify();
        }
    }

    public MyTime() {
        Thread thread = new Thread(() -> {
            while (true) {
                try {
                    synchronized (this) {
                        while (queue.isEmpty()) {
                            this.wait();
                        }
                        MyTask myTask = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= myTask.getTime()) {
                            myTask.run();
                            queue.poll();
                        } else {
                            this.wait(myTask.getTime() - curTime);
                        }
                    }
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.setDaemon(true);
        thread.start();
    }
}

4. 线程池

4.1 概述

线程池是一种管理和复用线程的编程模式。它预先创建一定数量的线程，任务到来时分配给空闲线程，从而避免频繁创建销毁线程的开销。

核心作用：

• 优化效率：复用线程，减少上下文切换成本。
• 资源控制：限制最大并发数，保护系统不被压垮。
• 任务排队：维护任务队列，缓冲突发流量。

标准库线程池参数：

1. corePoolSize：核心线程数。
2. maximumPoolSize：最大线程数。
3. keepAliveTime：非核心线程空闲存活时间。
4. unit：时间单位。
5. workQueue：任务队列。
6. threadFactory：线程工厂。
7. handler：拒绝策略。

4.2 线程池执行流程

假设线程池配置：核心线程 2，最大线程 4，等待队列容量 2。

1. 任务数量 ≤ 2：由核心线程直接执行。
2. 2 < 任务数量 ≤ 4：核心线程忙不过来，多余任务进入等待队列。
3. 4 < 任务数量 ≤ 6：等待队列满，线程池扩容至最大线程数（4），新任务由非核心线程执行。
4. 任务数量 > 6：所有资源占满，触发拒绝策略。

4.3 拒绝策略

当线程池无法处理新任务时，会执行拒绝策略：

1. AbortPolicy：直接抛出 RejectedExecutionException 异常。
2. CallerRunsPolicy：由提交任务的线程自己执行该任务，起到降级限流作用。
3. DiscardPolicy：直接丢弃新任务，不抛异常。
4. DiscardOldestPolicy：丢弃队列中最老的任务，然后尝试重新提交当前任务。

4.4 模拟实现线程池

public class MyThreadPoolExecutor {
    private final int capacity = 1000; // 阻塞队列
    private final MyBlockingQueue queue = new MyBlockingQueue(capacity);
    private final List<Thread> list = new ArrayList<>();

    // 创建线程
    public MyThreadPoolExecutor(int n) {
        for (int i = 0; i < n; i++) {
            Thread thread = new Thread(() -> {
                while (true) {
                    try {
                        queue.take().run();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            thread.start();
            list.add(thread);
        }
    }

    // 添加任务
    public void submit(Runnable runnable) throws InterruptedException {
        queue.put(runnable);
    }

    public int getCapacity() {
        return capacity;
    }

    public List<Thread> getList() {
        return list;
    }
}

以上四个并发模型构成了 Java 高并发编程的基石。在实际开发中，建议优先使用 JDK 提供的成熟工具类（如 ConcurrentHashMap, Executors, ScheduledThreadPoolExecutor），但在面试或底层优化时，理解这些原理至关重要。