在实际开发中，多线程不仅仅是“会创建线程”那么简单。如何安全地共享数据、如何协调多个线程之间的协作、如何提升系统性能，才是工程中的重点。本文结合经典案例，深入理解：单例模式、生产者-消费者模型、阻塞队列、定时器、线程池等核心多线程应用场景。

一、设计模式：

       设计模式是 Java 开发中针对常见设计问题的可复用、经过验证的解决方案模板。

1.单例模式

一句话概括：单例模式保证一个类在程序中只有一个实例（对象），并提供一个全局访问点，分为懒汉和饿汉两个模式。

作用：
1. 控制资源访问，避免浪费：如如打印机驱动、日志文件写入器等，多实例可能造成文件锁冲突或设备状态不一致。
2.维护全局状态的一致性：如应用的配置信息（如数据库URL、环境变量）应该只加载一次，所有模块都从同一个对象获取，保证数据统一。
3.避免逻辑冲突和错误：如计数器、ID生成器如果存在多个实例，各自维护计数，会导致ID重复或计数不准确。
4.简化设计，提供全局访问点：消除了需要将对象实例层层传递的麻烦，任何地方都可以通过 getInstance() 直接获取，降低了耦合度，也让系统的结构更清晰。

常见场景：DataSource、Runtime、日志管理器等。

①饿汉模式：提前加载。类加载时即完成实例创建，天然线程安全

因为：JVM 通过内部锁机制确保该类只被加载一次，且静态变量 instance只初始化一次

public class SingletonHungry {
    //构造方法私有化，保证外部不能调用构造方法初始化（new）对象(实例)
    private SingletonHungry() {}

    //静态成员初始化是在加载类时，这里会自动初始化对象instance
    private static final SingletonHungry instance = new SingletonHungry();  
    
    //直接调用SingletonHungry.getInstance()获取上面构建好的instance
    public static SingletonHungry getInstance() {
        return instance;
    }
}

②懒汉模式--多线程版：用时加载。使用的时候才创建实例，需要处理线程安全问题。

public class SingletonLazy {
    //⭐volatile防止指令重排序
    private static volatile SingletonLazy instance;  //调用getInstance()时候才实例化
    private SingletonLazy() {}
    public static SingletonLazy getInstance() {

        //⭐第一次检查：若实例存在（不为null）则直接返回，不需要加锁，提升性能
        if (instance == null) {
            synchronized (SingletonLazy.class) {   //class表示锁的是类对象
                //⭐第二次检查：避免重复实例化，new的开销很大
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

⭐volatile：volatile 修饰instance，具体到 instance = new SingletonLazy() 这一行，这个过程涉及1分配内存、2初始化对象、3赋值引用这三个步骤，可能被jvm优化成1-3-2，这时return instance可能拿到的是只经过13没有经过2初始化对象的实例。

⭐第一次判空：判断是否要加锁，若instance ！=null，两个线程去同时访问就不需要进行锁的竞争。

⭐第二次判空：保证线程安全，避免重复实例化。因为如果没有第二个if，t1线程首先在第一个if判断为空，然后紧接着t2线程也去在第一个if发现也为空，就会创建两个实例。

2.生产者-消费者模型

一句话概括：生产者-消费者模型是一种通过共享缓冲区，解耦生产者和消费者，并协调数据生产与处理速率差异的并发协作模式。

构成：
生产者：负责生成数据，并将数据放入共享缓冲区。
消费者：负责从共享缓冲区取出数据并进行处理。
共享缓冲区（通常为阻塞队列）：用于存放生产者生成的数据，解耦生产者和消费者，同时解决速率不匹配问题。
---除此之外，通常还需要同步机制（如锁、信号量）来保证线程安全，避免数据竞争

作用：
解耦：生产者和消费者不直接依赖。
削峰填谷：缓冲队列可以平衡生产者和消费者处理数据的速度差异。
缺点：比较复杂；性能较低（引入了锁竞争）

常见场景：
线程池任务队列：生产者（主线程或任意线程提交 Runnable / Callable 任务）缓冲区（线程池内部的任务阻塞队列）消费者（线程池中的工作线程，执行任务）
订单/支付异步处理：生产者（用户下单/支付请求触发消息）缓冲区（消息队列）消费者（库存扣减、积分发放、通知等后台任务，保证核心链路快速响应）

//⭐基于阻塞队列的实现
public class ProducerConsumer {
    private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5);//容量为5

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            try {  // 生产者线程：生成0-9共10个整数放入队列
                for (int i = 0; i < 10; i++) {
                    queue.put(i);                //当队列满时，放不进去，put() 会阻塞
                    System.out.println("生产：" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();  //重新将中断标志设为 true
            }
        });

        Thread consumer = new Thread(() -> {
            try {  // 消费者线程：从队列中取出10个整数并消费
                for (int i = 0; i < 10; i++) {
                    Integer val = queue.take();  //当队列空时，取不出来，take() 会阻塞
                    System.out.println("消费：" + val);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
// 启动生产者和消费者线程
        producer.start();
        consumer.start();
    }
}

⭐阻塞队列:

  BlockingQueue 位于 java.util.concurrent 包中。它是 Java 并发工具包（JUC）提供的阻塞队列接口，用于简化多线程间的数据共享与同步。BlockingQueue 也有 offer，poll，peek等方法，但是这些方法不带有阻塞特性

·插入元素：add(e)；offer(e)；offer(e, time, unit)；
常用--put(e)：队列满时阻塞，直到有空间可用。

·移除元素：remove()；poll()；poll(time, unit)；

常用--take()：队列空时阻塞，直到有元素可取。

·检查队首（不删除）：element()；peek()：队列空时返回 null。

常用实现类

类	特点
ArrayBlockingQueue-基于数组	内部使用一个ReentrantLock可重入锁（生产消费共用），公平性可配置，同一时刻只有一个线程能访问队列，初始化时必须指定容量
LinkedBlockingQueue-基于链表	默认容量为 Integer.MAX_VALUE，使用两个锁（putLock 和 takeLock），生产者之间互斥，消费者之间互斥，但生产者和消费者可以同时操作
PriorityBlockingQueue-基于二叉堆的优先级阻塞队列	无界优先级阻塞队列，需实现Comparable接口重写compareTo方法。不支持take()的公平等待
SynchronousQueue- 容量为0	容量为0的阻塞队列，插入put操作必须等待另一个线程的移除take操作，反之亦然。适用于生产者和消费者一一对应的场景

二、定时器

一句话概括：定时器是软件开发中的⼀个重要组件，类似于⼀个 "闹钟"，作用是在指定的时间点或延迟后执行任务，并可以按固定周期重复执行。
Timer类位于java.util.Timer，核心方法为schedule（相对轻量但单线程，任务耗时可能影响后续调度）ScheduledExecutorService（基于线程池，更灵活可靠）

构成：
任务队列：每个元素是一个Task任务（Task带有时间属性），通常使用优先级队列（按下次执行时间排序），确保最早到期的任务排在队首。---不要使⽤ PriorityBlockingQueue, 容易死锁
调度线程：一个独立的worker线程不断检查任务队列，计算当前时间与最近任务执行时间的差值，通过 wait / sleep 或条件等待实现精确调度。
时间控制机制：依赖系统时钟获取当前时间，并与任务的下次执行时间进行比较，决定是否立即执行或继续等待。
任务执行器：当任务到达触发时间时，由调度线程（如 java.util.Timer）或线程池（如 ScheduledExecutorService）来执行任务。若使用单线程调度器，长时间运行的任务会阻塞后续任务；若使用线程池，则支持并发执行。
任务管理接口：提供添加、取消任务的方法（如 schedule、cancel），允许在运行时动态调整任务计划。

常见场景：
延迟执行：例如订单支付超时关闭、延迟发送通知。
周期性任务：如定时备份数据、心跳检测、日志清理、定时拉取配置。
调度任务：在特定时间（如每天凌晨）执行批处理或报表生成。
超时控制：设置操作的最大等待时间，超时后执行回退或重试逻辑。

//标准库定时器Timer
Timer timer = new Timer();
timer.schedule(new TimerTask() {   //⭐核心方法
    @Override
    public void run() {
        System.out.println("任务执行");
    }
}, 3000); // 3秒后执行

⭐-----schedule 包含两个参数： 第⼀个参数指定即将要执⾏的任务代码, 第⼆个参数指定多⻓时间之后执⾏ (单位为毫秒)

----TimerTask是抽象类，实现了 Runnable 接口（因此该实例本质上是一个可执行的任务）

----new TimerTask() { ... } 创建了一个匿名内部类的实例（这个匿名类是TimerTask的子类）

，并重写了其中的 run() 方法。因为TimerTask是抽象类，抽象类不可被实例化，但是其子类可以。

//手写简易定时器:核心--优先级队列 + 独立扫描线程
public class MyTimer {
    //内部任务类，实现了 Comparable 接口，按执行时间排序
    private static class Task implements Comparable<Task> {  
        Runnable command;   // 要执行的任务逻辑
        long time;          // time毫秒后执行
        public Task(Runnable command, long delay) {
            this.command = command;
            // 计算任务的绝对执行时间 = 当前时间 + 延迟毫秒数
            this.time = System.currentTimeMillis() + delay;
        }
        // 按执行时间升序排序，时间小的优先级高（队首是最早要执行的任务）
        @Override
        public int compareTo(Task o) {
            return Long.compare(this.time, o.time);
        }
    }
    // ⭐优先级阻塞队列，线程安全且按任务执行时间自动排序
    private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();

    public MyTimer() {
        //启动一个工作线程，不断从队列中获取任务并执行
        Thread worker = new Thread(() -> {
            while (true) {   //一个线程循环处理任务
                try {
                    // ⭐阻塞获取队首任务（最早要执行的任务）
                    Task task = queue.take();  //
                    long now = System.currentTimeMillis();
                    // ⭐如果任务还没到执行时间，就让线程睡眠等待，定时阻塞
                    if (task.time > now) {
                        Thread.sleep(task.time - now);
                    }
                    task.command.run();
                } catch (InterruptedException e) {
                    break;       // 线程被中断时退出循环（简单处理）
                }
            }
        });
        worker.start();      // 启动工作线程
    }

    public void schedule(Runnable command, long delay) {
        // 创建任务对象并放入队列，工作线程会适时处理
        queue.put(new Task(command, delay));
    }
}

⭐PriorityBlockingQueue，容易死锁：

·比较器本身持有了其他锁lockB：在比较器的 compare 方法中，编写了获取另一把锁（如一lockB）的代码。当线程 A 在执行 queue.put 时，它已经持有了队列的内部锁（称为 lockQ），然后在调用比较器时又尝试获取 lockB。

·锁lockB与队列操作锁形成了循环等待：假设线程 A 和线程 B 同时操作同一个 PriorityBlockingQueue，但B线程先拿到了lockB

具体理解如下：

• 线程 A：正在执行 queue.put → 已经获取了队列内部锁 lockQ → 调用比较器的 compare 方法 → 试图获取业务锁 lockB（但此时 lockB 被线程 B 持有）。

• 线程 B：正在执行其他代码，持有了 lockB，并且此时它想执行 queue.put 或 queue.take，于是尝试获取队列内部锁 lockQ（但 lockQ 被线程 A 持有）。

• 这样就形成了 循环等待：A 等 B 释放 lockB；B 等 A 释放 lockQ

⭐阻塞获取队首任务：当队列为空时，当前线程会进入阻塞状态，暂停执行，直到有其他线程调用 queue.put() 放入任务，（阻塞状态：会让出cpu，上下文消耗比较大）

⭐Thread.sleep() 是一种阻塞操作，线程会进入 TIMED_WAITING 状态，直到休眠时间结束或被中断后重新进入就绪队列等待调度。

三、线程池

一句话概括：线程池是一种通过复用一组预先创建的线程来执行任务的技术，旨在降低线程创建销毁开销、提高响应速度并有效控制系统资源。

作用：
减少线程创建和销毁的开销
统一管理线程资源
提升系统响应速度

常见场景：
Web 服务器：如 Tomcat、Jetty 使用线程池处理并发 HTTP 请求，避免为每个请求创建新线程。
批量数据处理：如报表生成、数据导入/出、批量文件处理，利用线程池并行处理，提高吞吐量。

Executors 和 ExecutorService 是 Java 并发包（java.util.concurrent）中用于线程池的两个核心组件：

·ExecutorService：是一个接口，继承自 Executor 接口

·Executors：是一个工具类（静态工厂类），提供了大量静态方法用于快速创建不同类型的 ExecutorService 实例。Executors本质上是 ThreadPoolExecutor 类的封装。Executors工厂方法底层都是调用ThreadPoolExecutor构造函数创建的

·工厂类是指运用工厂模式（创建型设计模式）的类，其核心职责是封装对象的创建逻辑，让调用者无需关心具体构造细节，只需通过简单的方法调用即可获取所需对象。

·【Executor ← ExecutorService ← ThreadPoolExecutor】

Executor 是最顶层的接口；ExecutorService 继承自 Executor；ThreadPoolExecutor 是 ExecutorService 的一个具体实现类

//标准库常见线程池---Executors 创建线程池的⼏种⽅式

//创建固定线程数的线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(5);
//创建线程数⽬动态增⻓的线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();
//创建只包含单个线程的线程池
ExecutorService singlePool = Executors.newSingleThreadExecutor();
/*设定延迟时间后执⾏命令，或者定期执⾏命令.
是进阶版的 Timer. */
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);

//构造方法
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

//实例化：固定大小线程池（模拟 newFixedThreadPool
// 核心=最大=5，队列为无界LinkedBlockingQueue
ThreadPoolExecutor fixedPool = new ThreadPoolExecutor(
        5, 5, 0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<>()
);
for (int i = 0; i < 10; i++) {
    fixedPool.execute(() -> System.out.println(Thread.currentThread().getName()));
}
fixedPool.shutdown();

//fixedPool实例可使用的方法
//提交任务
execute(Runnable command)  //无返回值，执行任务。
submit(Callable<T> task)  //返回 Future<T>，可获取结果或异常。
submit(Runnable task, T result)  //返回带结果的 Future。
//关闭线程池
shutdown()  //拒绝新任务，等待已提交任务执行完。
shutdownNow()  //尝试停止正在执行的任务，返回未执行的任务列表。
awaitTermination(long timeout, TimeUnit unit)  //阻塞等待线程池完全关闭。

ThreadPoolExecutor 核心参数

参数	说明
corePoolSize--核心线程数	一直存在线程池中的线程数
maximumPoolSize--最大线程数	最大线程数=核心+临时线程
keepAliveTime--临时线程允许空闲的时间	临时线程空闲keepAliveTime后要被销毁
unit--keepAliveTime的时间单位	是秒, 分钟, 还是其他值
workQueue--任务阻塞队列	传递任务的阻塞队列
threadFactory--线程工厂	通过不同线程⼯⼚创建出的线程相当于对⼀些属性进⾏了不同的初始化设置
RejectedExecutionHandler--拒绝策略	如果任务量超出线程池负荷了接下来怎么处理
拒绝策略有四种	AbortPolicy(): 超过负荷, 直接抛出异常 CallerRunsPolicy(): 调⽤者负责处理多出来的任务 DiscardOldestPolicy(): 丢弃队列中最⽼的任务 DiscardPolicy(): 丢弃新来的任务

总结：保证线程安全的思路

1. 无共享资源：线程私有数据，天然安全

2. 只读共享：

   • 不可变对象（如 String、Integer）

   • 并发容器（ConcurrentHashMap）

3. 主动同步：

   • 原子性：synchronized、Lock、AtomicXXX

   • 可见性：volatile、synchronized

   • 顺序性：happens-before 原则