Java 多线程学习笔记：从基础创建到线程池与线程安全-优快云博客

1. 什么是线程？

线程是进程内的执行单元，一个进程可以包含多个线程，共享进程资源（内存、文件描述符等），但有自己的栈空间。
目的：提高程序执行效率（并发处理任务）。

2. 线程的状态（Java 中）

新建（New）：线程对象创建后，未调用 start () 方法；
就绪（Runnable）：调用 start () 后，等待 CPU 调度（包含 Running 状态）；
阻塞（Blocked）：等待锁释放（如 synchronized 未获取到锁）；
等待（Waiting）：无限期等待（如 wait ()、join () 未指定时间）；
超时等待（Timed Waiting）：有限期等待（如 sleep (1000)、wait (1000)）；
终止（Terminated）：线程执行完毕或异常终止。

线程的创建

1. 继承 Thread 类

步骤：

继承 Thread 类，重写 run() 方法（线程执行的任务）；
创建子类实例，调用 start() 方法启动线程（而非直接调用 run()，start() 会触发 JVM 创建新线程并执行 run()）。

代码示例：

// 1. 定义线程类，继承 Thread
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 执行：" + i);
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        // 2. 创建线程实例
        MyThread thread = new MyThread();
        // 3. 启动线程（调用 start()，而非 run()）
        thread.start(); 
        
        // 主线程执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行：" + i);
        }
    }
}

特点：

简单直接，但 Java 是单继承，继承 Thread 后无法再继承其他类，灵活性低。

2. 实现 Runnable 接口

步骤：

实现 Runnable 接口，重写 run() 方法；
创建 Runnable 实现类的实例，作为参数传入 Thread 构造器；
调用 Thread 实例的 start() 方法启动线程。

代码示例：

// 1. 实现 Runnable 接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的任务
        for (int i = 0; i < 5; i++) {
            System.out.println("线程 " + Thread.currentThread().getName() + " 执行：" + i);
        }
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        // 2. 创建 Runnable 实例
        MyRunnable runnable = new MyRunnable();
        // 3. 包装成 Thread 并启动
        Thread thread = new Thread(runnable);
        thread.start(); 
        
        // 主线程任务
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行：" + i);
        }
    }
}

特点：

避免单继承限制（可同时实现其他接口），推荐优先使用；
适合多线程共享同一个任务资源的场景（如多个线程操作同一个计数器）。

3. 实现 Callable 接口（带返回值）（了解）

步骤：

实现 Callable<T> 接口（T 为返回值类型），重写 call() 方法（可抛异常）；
将 Callable 实例包装成 FutureTask（兼具 Runnable 和 Future 功能）；
把 FutureTask 作为参数传入 Thread 构造器，调用 start() 启动线程；
通过 FutureTask.get() 获取任务返回值（会阻塞当前线程，直到任务执行完毕）。

代码示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

// 1. 实现 Callable 接口，指定返回值类型为 Integer
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
            System.out.println("线程计算中：" + i);
        }
        return sum; // 返回计算结果
    }
}

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 2. 创建 Callable 实例
        MyCallable callable = new MyCallable();
        // 3. 包装成 FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        // 4. 启动线程
        new Thread(futureTask).start();
        
        // 5. 获取返回值（主线程会等待子线程执行完才获取结果）
        int result = futureTask.get();
        System.out.println("计算结果：" + result); // 输出：15
    }
}

特点：

支持返回任务结果，可处理异常；
适合需要获取任务执行结果的场景（如多线程计算后汇总结果）。

线程池

在这里插入图片描述

上述方式使用的需要不断重复创建销毁浪费资源所以我们引入线程池的概念

这里与数据库连接类似重复创建又销毁浪费资源所以我们用到 线程池

线程池可自己创建（难度大）所以这里使用JDK自带的线程池 ThreadPoolExecutor

对比项	线程池	手动创建线程
资源消耗	复用线程，消耗低	频繁创建 / 销毁，消耗高
并发控制	可控制最大线程数，避免资源耗尽	无限制，可能导致线程过多、CPU 过载
响应速度	线程已创建，任务提交后快速执行	需先创建线程，响应慢
管理难度	统一管理（如监控、关闭）	需手动管理，复杂

ThreadPoolExecutor的七大核心参数的七大核心参数

核心线程数（corePoolSize）：线程池长期保持的线程数量
最大线程数（maximumPoolSize）：线程池允许创建的最多线程数量
空闲时间（keepAliveTime）：超出核心线程数的线程，空闲多久会被销毁
时间单位（unit）：空闲时间的单位（如秒、毫秒等）
任务队列（workQueue）：存放等待执行任务的队列
线程工厂（threadFactory）：用于创建线程的工厂
拒绝策略（handler）：任务太多处理不过来时，对新任务的处理策略（如抛异常、丢弃等）

核心线程、临时线程及任务执行逻辑

一、线程池中的两种线程

线程类型	核心参数关联	存活特性
核心线程	由 corePoolSize 设定	长期存在（即使空闲），除非设置 allowCoreThreadTimeOut=true（允许核心线程超时销毁）
临时线程	数量 = maximumPoolSize - corePoolSize	仅任务繁忙时临时创建，空闲超过 keepAliveTime 后会被销毁

二、任务执行流程与临时线程创建时机

1. 任务执行优先级（按顺序判断）

核心线程是否未满？是 → 创建核心线程执行任务
核心线程已满？→ 任务队列是否未满？是 → 任务入队等待
队列已满？→ 总线程数是否未达 maximumPoolSize？是 → 创建临时线程执行任务
总线程数达 maximumPoolSize？→ 触发拒绝策略

2. 临时线程创建条件（必须同时满足）

核心线程已全部在工作（corePoolSize 满）
任务队列已装满（无空闲队列空间）
有新任务提交，且总线程数 < maximumPoolSize

3. 示例理解（以 core=2、max=3、队列容量 = 4 为例）

任务数 1~2：核心线程执行（线程数 = 2）
任务数 3~6：核心线程 + 队列等待（线程数仍 = 2）
任务数 7：队列装满（4 个），核心线程满（2 个），仍无临时线程（总线程数未超 max，但无新任务触发）
任务数 8：核心满 + 队列满 + 新任务，创建临时线程（线程数 = 3，达 max）

三、关键总结

核心线程是 “常驻部队”，临时线程是 “应急部队”
临时线程是 “最后防线”，仅核心线程不够用、队列也装不下时才会创建
任务处理优先级：核心线程 > 任务队列 > 临时线程 > 拒绝策略

任务队列

选择LinkedBlockingQueue还是ArrayBlockingQueue作为ThreadPoolExecutor的任务队列，需结合两者特性和业务需求：

LinkedBlockingQueue：底层是链表结构，默认无界（容量极大，易因任务堆积导致 OOM），若手动指定容量则为有界；插入删除效率高（无需移动元素），但不支持公平性。适合任务量少且稳定、追求队列操作效率，或内存充足且能接受临时大量任务堆积的场景（需手动指定容量控制风险）。

ArrayBlockingQueue：底层是数组结构，必须指定容量（有界），内存占用可控；插入删除时可能需要移动元素，效率略低，但支持公平性（按任务提交顺序执行）。适合需严格控制内存占用、任务峰值可预估的场景（如秒杀系统），能配合拒绝策略避免资源耗尽，是生产环境的优先选择。
核心建议：生产环境尽量用有界队列，优先选ArrayBlockingQueue；若用LinkedBlockingQueue，务必指定容量，避免无界队列导致的 OOM 风险。

线程工厂

1. 线程工厂的作用

统一线程创建逻辑：避免在代码中零散创建线程，便于集中管理线程属性（如统一命名规范，方便日志排查）。
自定义线程特性：根据业务需求设置线程的优先级、是否为守护线程（后台线程）、异常处理器等。
与线程池配合：线程池在需要新线程时（如核心线程初始化、创建临时线程），会调用线程工厂的 newThread(Runnable r) 方法生成线程。

2. 核心接口定义

ThreadFactory 是一个函数式接口，仅包含一个方法：

public interface ThreadFactory {
    // 创建一个新线程，传入任务（Runnable），返回线程实例
    Thread newThread(Runnable r);
}

3. 默认线程工厂（Executors.defaultThreadFactory ()）

JDK 提供了默认实现 Executors.defaultThreadFactory()，其创建的线程具有以下特点：

线程名称格式：pool-{线程池编号}-thread-{线程编号}（如 pool-1-thread-1），便于追踪线程归属。
非守护线程（setDaemon(false)）：不会随着主线程退出而自动终止，需线程池主动关闭。
线程优先级为 Thread.NORM_PRIORITY（默认优先级 5）。
未设置未捕获异常处理器（UncaughtExceptionHandler），线程异常会直接打印到控制台。

4. 自定义线程工厂（示例）

实际开发中，常需自定义线程工厂以满足特定需求（如命名规范、异常处理）。以下是一个示例：

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class CustomThreadFactory implements ThreadFactory {
    // 线程池名称前缀（用于区分不同线程池）
    private final String poolName;
    // 线程计数器（用于生成线程编号）
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    // 是否为守护线程
    private final boolean isDaemon;
    // 线程优先级
    private final int priority;

    // 构造器：指定线程池名称、是否为守护线程、优先级
    public CustomThreadFactory(String poolName, boolean isDaemon, int priority) {
        this.poolName = poolName;
        this.isDaemon = isDaemon;
        this.priority = priority;
    }

    @Override
    public Thread newThread(Runnable r) {
        // 创建线程，传入任务
        Thread thread = new Thread(r);
        // 自定义线程名称（如 "order-pool-thread-1"）
        thread.setName(poolName + "-thread-" + threadNumber.getAndIncrement());
        // 设置是否为守护线程
        thread.setDaemon(isDaemon);
        // 设置优先级（需在 1-10 之间，默认 5）
        thread.setPriority(priority);
        // 设置未捕获异常处理器（统一处理线程异常）
        thread.setUncaughtExceptionHandler((t, e) -> {
            System.err.println("线程 " + t.getName() + " 发生异常：" + e.getMessage());
            // 可在此处添加日志记录、告警等逻辑
        });
        return thread;
    }

    // 使用示例
    public static void main(String[] args) {
        // 创建自定义线程工厂：订单处理线程池，非守护线程，优先级 5
        ThreadFactory factory = new CustomThreadFactory("order-pool", false, Thread.NORM_PRIORITY);
        
        // 线程池中使用该工厂
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 3, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(4),
            factory, // 传入自定义线程工厂
            new ThreadPoolExecutor.AbortPolicy()
        );
    }
}

5. 自定义线程工厂的常见场景

线程命名规范化：通过业务标识（如 pay-pool、log-pool）区分线程池，方便日志排查和监控。
异常统一处理：设置 UncaughtExceptionHandler，对线程运行中未捕获的异常进行日志记录或告警（避免异常静默丢失）。
守护线程需求：创建守护线程（如后台监控线程），随主线程退出而终止，避免程序无法退出。
优先级调整：对核心任务设置较高优先级（如 Thread.MAX_PRIORITY），确保优先执行。

总结

线程工厂是线程池创建线程的 “工厂类”，负责线程的属性配置。
默认工厂可满足基础需求，自定义工厂能更灵活地适配业务（命名、异常、优先级等）。
合理使用线程工厂，能提升线程管理的规范性和可维护性，尤其在多线程池场景中作用显著。

拒绝策略

ThreadPoolExecutor 内置了 4 种拒绝策略（实现 RejectedExecutionHandler 接口），当线程池队列已满且线程数达到最大线程数时，会根据拒绝策略处理新提交的任务，核心区别如下：

1. AbortPolicy（默认策略）

行为：直接抛出 RejectedExecutionException 异常，阻止新任务提交。
特点：快速失败，明确告知任务被拒绝，适合需要严格保证任务不丢失的场景（需手动捕获异常处理）。
示例：

new ThreadPoolExecutor.AbortPolicy()

2. CallerRunsPolicy

行为：让提交任务的线程（调用者线程）自己执行该任务，减缓新任务提交速度。
特点：不会丢弃任务，也不抛异常，但会阻塞调用者线程，间接起到 “削峰” 作用，适合任务量波动较大的场景。
示例：

new ThreadPoolExecutor.CallerRunsPolicy()

3. DiscardPolicy

行为：直接丢弃新提交的任务，不抛异常，也不通知。
特点：简单粗暴，可能导致任务丢失，适合任务可容忍丢失的场景（如日志收集等非核心任务）。
示例：

new ThreadPoolExecutor.DiscardPolicy()

4. DiscardOldestPolicy

行为：丢弃队列中最旧的任务（最早提交但未执行的任务），然后尝试提交新任务。
特点：会丢失旧任务，但保证新任务有机会执行，适合 “新任务比旧任务更重要” 的场景（如实时数据处理）。
示例：

new ThreadPoolExecutor.DiscardOldestPolicy()

总结

拒绝策略	核心行为	适用场景	风险
AbortPolicy	抛异常	需严格保证任务不丢失	可能中断业务流程
CallerRunsPolicy	调用者线程执行新任务	任务量波动大，需削峰	可能阻塞调用者
DiscardPolicy	直接丢弃新任务	任务可容忍丢失	任务丢失无感知
DiscardOldestPolicy	丢弃最旧任务，提交新任务	新任务优先级高于

线程安全

什么是线程安全？

线程安全是指，当多个线程同时访问一个对象或共享资源时，无论这些线程的执行顺序如何交错，最终得到的结果都与单线程执行时的结果一致，并且不会出现数据损坏、死锁等意外情况

简单来说，就是多个线程 “有序地” 访问共享资源，不会互相干扰。

如下代码

当多个线程进入时第一个线程进入到第一个线程进入到else 未执行到ticket-- 第二个线程也已经进入else 此时如果ticket==1 就会出现超卖情况

public class TicketRunnable implements Runnable{  
    //票数  
    private int ticket = 100;  
  
    @Override  
    public void run() {  
        while(true){  
            if(ticket<=0){  
                System.out.println("票卖完了");  
                break;  
            }else {  
                try {  
                    Thread.sleep(5);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }                ticket--;  
                System.out.println(Thread.currentThread().getName()+"剩余"+ticket);  
            }        }    }}

`synchronized` 关键字的作用

synchronized 关键字是 Java 中最基本的同步机制，它能够保证在同一时刻，只有一个线程可以执行被它修饰的方法或代码块。

你可以把 synchronized 想象成一个锁或者一个会议室：

线程在执行 synchronized 方法前，必须先获取这把锁。
如果锁已经被其他线程持有，当前线程就必须等待，直到锁被释放。
线程执行完 synchronized 方法后，会释放这把锁，以便其他等待的线程可以获取它。

public class TicketRunnable implements Runnable{  
    //票数  
    private int ticket = 100;  
  
    @Override  
    public synchronized void run() {  
        while(true){  
            if(ticket<=0){  
                System.out.println("票卖完了");  
                break;  
            }else {  
                try {  
                    Thread.sleep(5);  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }                ticket--;  
                System.out.println(Thread.currentThread().getName()+"剩余"+ticket);  
            }        }    }}

总结：`synchronized` 如何解决问题

原子性：synchronized 将 if(ticket > 0)、Thread.sleep(5)、ticket-- 和 System.out.println(...) 这一整段逻辑变成了一个原子操作。一旦一个线程开始执行，它就会一直执行到底，不会被其他线程打断。
可见性：当一个线程释放锁时，它对共享变量（ticket）的修改会被强制刷新到主内存中。当另一个线程获取锁时，它会从主内存中重新读取最新的变量值。这保证了线程间数据的可见性。
有序性：synchronized 可以保证在锁内的代码是按顺序执行的，避免了 JVM 指令重排序可能带来的问题。

Java 多线程学习笔记：从基础创建到线程池与线程安全

1. 什么是线程？

2. 线程的状态（Java 中）

线程的创建

1. 继承 Thread 类

2. 实现 Runnable 接口

3. 实现 Callable 接口（带返回值）（了解）

线程池

核心线程、临时线程及任务执行逻辑

一、线程池中的两种线程

二、任务执行流程与临时线程创建时机

1. 任务执行优先级（按顺序判断）

2. 临时线程创建条件（必须同时满足）

3. 示例理解（以 core=2、max=3、队列容量 = 4 为例）

三、关键总结

任务队列

线程工厂

1. 线程工厂的作用

2. 核心接口定义

3. 默认线程工厂（Executors.defaultThreadFactory ()）

4. 自定义线程工厂（示例）

5. 自定义线程工厂的常见场景

总结

拒绝策略

1. AbortPolicy（默认策略）

2. CallerRunsPolicy

3. DiscardPolicy

4. DiscardOldestPolicy

总结

线程安全

什么是线程安全？

synchronized 关键字的作用

总结：synchronized 如何解决问题

`synchronized` 关键字的作用

总结：`synchronized` 如何解决问题