Java on Coder_Studio

Java线程与操作系统线程的生命周期

Wed, 01 Apr 2026 14:12:15 +0000

一篇搞懂：Java包名、Maven artifactId、Spring application.name到底有啥区别？

Fri, 27 Mar 2026 21:33:09 +0000

项目文件夹叫codeedge-backend，Java包名是codeedgebackend，Maven的artifactId是codeedge-backend，Spring配置里还有个spring.application.name叫codeedge-backend。

这几个到底有啥区别？必须要对上吗？

其实，这几个是完全不同维度、不同作用、没有任何强制绑定关系的配置，给谁用、管什么、能不能乱改，差别还是挺大的。

我就用 codeedge-backend 项目当例子，先从最核心、最容易踩语法坑的 Java 包名说起。

Java包名 `com.codeedgexu.codeedgebackend`

这是Java语言强制规范的代码组织方式，是给Java编译器、JVM、Spring Boot看的，用来唯一标识代码类，和项目功能强绑定。

作用

唯一标识代码类，避免重名冲突

你的controller、config、service这些类，全在com.codeedgexu.codeedgebackend这个包下面。

Java编译器靠【包名+类名】唯一确定一个类，比如你的启动类全限定名是com.codeedgexu.codeedgebackend.CodeEdgeBackendApplication，这个名字全局唯一，不会和别人的项目重名冲突。

决定Spring Boot的Bean扫描范围

Spring Boot启动的时候，默认只会扫描启动类所在的包以及它的子包。

比如你的启动类在com.codeedgexu.codeedgebackend下面，那它只会扫这个包下面的controller、service，把它们注册成Bean。

如果改了代码的包名，但启动类没跟着搬到新包，Spring 就扫不到新包里的 controller、service 这些类，导致这些类不会被注册成 Bean，项目启动失败。

小贴士

Java包名里，绝对不能用横杠-。

因为横杠在Java里是减号运算符，不能出现在包名、类名、变量名里，编译器会直接报错。

这也是为什么我文件夹名可以叫codeedge-backend，但包名必须写成codeedgebackend的根本原因——不是我不想写一样的，是Java语法不允许。

Java包名的所有部分必须全小写。

这是Java的行业通用规范，虽然语法允许大写，但不专业，且很多代码规范检查工具会报错。

Maven artifactId `codeedge-backend`

这是Maven项目的唯一标识，在同一个groupId下必须唯一，用来在Maven仓库里找到你的项目、打包发布、管理依赖。

作用

唯一标识你的Maven项目，和别人的项目区分开；
项目打包、发布到Maven仓库，全靠这个artifactId；
以后别人要引用你的项目，就是靠这个artifactId写依赖：

<dependency>
    <groupId>com.codeedgexu</groupId>
    <artifactId>codeedge-backend</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

小贴士

上线后如果修改了 artifactId，项目打包出来的jar包名字会变，别人引用你的项目也要同步改artifactId，不然就找不到依赖。

推荐用kebab-case短横线分隔的格式（比如codeedge-backend），可读性好，Maven全兼容，是行业里90%的项目都会用的写法。

`application.yml`文件中的`codeedge-backend`

1
2
3

spring:
  application:
    name: codeedge-backend

这是Spring Boot应用的官方服务名，核心作用是给微服务注册中心（Nacos）看的，是你这个服务在微服务集群里的唯一标识。

作用

Nacos服务注册的唯一标识

你的服务启动时，会去Nacos登记，登记的名字就是这个spring.application.name；

微服务之间调用的标识

以后有其他服务要调用你的接口，就是靠这个名字在Nacos里找到你的服务地址；

小贴士

同样地，上线后如果修改了这个服务名，Nacos里注册的服务名就变了，其他服务再用旧名字找你，就完全找不到了，微服务调用直接报错。

推荐和Maven的artifactId保持一致（比如也叫codeedge-backend），这样你在看Nacos控制台的时候，一眼就能对应上“这个服务对应Maven里的哪个项目”，不会混乱。

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

Thu, 26 Mar 2026 20:42:49 +0000

结构化输出、TokenStream、SSE、Flux、Reactor这几个概念刚接触时感觉很混乱，本文就来理一理，我用【AI生成一个电商商品详情页】的真实项目场景，把这些概念串起来，从业务需求到底层技术，一次性搞明白。

LangChain4j结构化输出

结构化输出是LangChain4j里的一个核心功能，能强制大模型返回标准的JSON/POJO组件树对象，而不是一段诸如“我给你加个按钮、加个图片”的自然语言。

之前你让AI生成商品详情页，它可能返回：

“好的，我帮你生成了一个详情页，顶部有个轮播图放3张商品图，中间有商品标题、价格、库存，底部有个‘立即购买’的红色按钮…”

然后你还得写自己大量文本解析逻辑，甚至还要用正则去提取轮播图数量、按钮颜色，又繁琐又容易出错，而且根本没法直接渲染成 Web 组件。

用了结构化输出，AI 会直接返回标准 JSON，之后 LangChain4j 会自动把 JSON 转成 Java 对象。底层默认使用 Jackson（Java 最主流的 JSON 库），只需要提前定义好页面结构的模板类，系统就能自动完成字段映射，完全不用写任何解析代码，直接就能喂给前端的渲染引擎。

TokenStream + SSE

TokenStream是LangChain4j提供的流式API，大模型生成一个Token（大概是一个字、半个JSON键或值），就立刻推给你，不用等整个组件树JSON生成完；

SSE（Server-Sent Events），把TokenStream里的JSON片段，实时推给前端的渲染引擎，实现“轮播图先出来、标题再出来、按钮最后出来”的逐个渲染效果。

之前你让AI生成一个复杂的Web应用，要等10-30秒整个JSON生成完，才能一次性渲染给用户，用户需要在空白的预览区页面长时间等待。

用了TokenStream + SSE，AI生成完一个完整的组件JSON片段，前端就立刻渲染这个组件，用户能实时看到进度。

Flux & Reactor

Reactor是Spring官方的响应式编程框架，专门用来处理高并发、异步、流式的场景；

Flux是Reactor的核心类之一，代表0到N个元素的异步序列，刚好对应AI生成的JSON片段流（一个JSON片段就是一个元素）。

如果用传统的同步编程，几百个用户同时请求生成Web应用，你需要开几百个线程，每个线程都要等10-30秒AI生成完，服务器的CPU、内存直接就爆了，根本扛不住。

用了 Flux + Reactor，就能彻底解决这个问题：

它是完全异步非阻塞 + 事件驱动的模型 —— 发起 AI 调用后，线程立刻释放去处理其他请求，绝不死等；等 AI 生成 Token 后，再主动通知线程来处理推送，1 个线程能同时管理几百个请求，所以只用 10-20 个线程就能扛住几百甚至上千的并发。

另外，它还自带背压机制：前端网速慢，服务端就自动放慢推送速度；前端快，就加快推送，永远不会让前端浏览器因为数据堆积而卡死。

一张图搞懂

一篇搞懂前后端所有的“器”

Wed, 25 Mar 2026 20:58:53 +0000

用一个电商场景中常见的用户下单流程，把前后端的所有“器”串起来：

前后端对比

层级	前端“器”	作用	后端“器”	作用
第一道关卡	路由守卫	页面访问权限控制	过滤器	跨域、编码、协议级过滤
第二道关卡	请求/响应拦截器	统一加Token、统一报错	拦截器	登录校验、权限验证
业务层	-	-	Controller	执行核心业务逻辑
业务增强层	-	-	AOP切面	日志、监控、事务增强，不侵入主业务代码
执行层	-	-	执行器	异步任务、线程池调度

其实啊，所有的“器”，本质上都是“关注点分离”的体现，即主业务代码只关心“下单”本身，而登录、跨域、日志、异步这些“脏活累活”，交给各种“器”去做。

【面试真题拆解】Java里面的线程池都有哪些参数？

Sun, 22 Mar 2026 15:09:10 +0000

那下一个问题，面试官接着问：

“ Java里面的线程池都有哪些参数？”

我当时就记得“核心线程数、最大线程数”，其他的应该还有5个，支支吾吾答不上来，直接就凉了。

线程池是用来管理线程的，避免频繁创建和销毁线程带来的性能开销。

类比一下工厂招工：

不用线程池

来一个任务就招一个新工人（创建线程），任务干完就辞退（销毁线程），频繁招工辞退，效率极低，还费钱；

用线程池

工厂提前招好一批固定工人（核心线程），任务来了直接让固定工人干，固定工人忙不过来就把任务放待办队列（工作队列），队列也满了就临时招几个临时工（非核心线程），临时工没活干了过段时间就辞退，效率高，还省钱。

线程池的7个核心参数

Java线程池的核心类是 ThreadPoolExecutor，它的构造方法有7个参数：

1. corePoolSize：核心线程数

工厂的正式工数量。

正式工是工厂的“长期工”，默认情况下，就算没活干，也不会被辞退；

任务来了，先让正式工干，正式工没满的话，直接创建正式工执行任务。

2. maximumPoolSize：最大线程数

工厂的正式工+临时工的总数量。

正式工忙不过来，待办队列也满了，就会招临时工；

正式工+临时工的总数，不能超过最大线程数。

3. keepAliveTime：空闲线程存活时间

工厂的临时工没活干的时候，多久会被辞退。

只有临时工（非核心线程）会被回收，正式工（核心线程）默认不会被回收；

但是，如果设置了 allowCoreThreadTimeOut(true)，正式工没活干了，过了这个时间也会被辞退。

4. unit：时间单位

空闲线程存活时间的单位。

比如 TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分钟）、TimeUnit.HOURS（小时）。

5. workQueue：工作队列

工厂的待办任务队列。

正式工（corePoolSize）都在忙，新任务来了就先放进待办队列，等正式工有空了再从队列里拿任务干。

6. threadFactory：线程工厂

给工厂的工人起名字的。

用来创建新线程，给线程设置名字、优先级、是否是守护线程等。

7. handler：拒绝策略

工厂的任务太多了，正式工、临时工、待办队列都满了，怎么处理新任务，就是靠这个参数定义的。

线程池的执行流程

提交新任务

工厂来了一个新任务；

判断核心线程数

先看正式工（corePoolSize）有没有满，没满的话，直接招一个正式工（创建核心线程）执行任务；

判断工作队列

如果正式工满了，就看待办队列（workQueue）有没有满，没满的话，把任务放进队列，等正式工有空了再拿；

判断最大线程数

如果队列也满了，就看正式工+临时工的总数（maximumPoolSize）有没有满，没满的话，招一个临时工（创建非核心线程）执行任务；

执行拒绝策略

如果最大线程数也满了，就执行拒绝策略（handler），处理这个新任务；

任务执行完

线程执行完任务，会从队列里拿下一个任务继续干；

空闲线程回收

如果是临时工（非核心线程），没活干的时间超过了 keepAliveTime，就会被回收（辞退）。

4种默认拒绝策略

拒绝策略	作用	适用场景
AbortPolicy（默认）	直接抛出RejectedExecutionException异常，拒绝执行新任务	对数据一致性要求高的场景，任务不能丢，必须让调用者知道任务被拒绝了
CallerRunsPolicy	由提交任务的线程（调用者线程）自己执行这个任务	对性能要求不高，任务不能丢的场景，比如日志记录
DiscardPolicy	直接丢弃新任务，不抛异常，也不做任何处理	对数据一致性要求不高，丢几个任务没关系的场景，比如非核心的监控数据上报
DiscardOldestPolicy	丢弃队列里最老的任务（等待时间最长的任务），然后把新任务放进队列	对数据一致性要求不高，但想尽量执行新任务的场景

ThreadPoolExecutor 的构造方法

import java.util.concurrent.*;

/**
 * 线程池示例
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 定义线程池的7个核心参数
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                5, // corePoolSize：核心线程数（5个正式工）
                10, // maximumPoolSize：最大线程数（5个正式工+5个临时工）
                60, // keepAliveTime：空闲线程存活时间（60秒）
                TimeUnit.SECONDS, // unit：时间单位（秒）
                new ArrayBlockingQueue<>(100), // workQueue：有界队列（容量100）
                Executors.defaultThreadFactory(), // threadFactory：默认线程工厂
                new ThreadPoolExecutor.AbortPolicy() // handler：默认拒绝策略（抛异常）
        );

        // 提交任务
        for (int i = 0; i < 200; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务：" + taskId);
            });
        }

        // 关闭线程池
        threadPool.shutdown();
    }
}

【面试真题拆解】Java的Static关键字到底怎么用？

Sun, 22 Mar 2026 13:06:05 +0000

面试官上来就问：

“ 那个Java里面的Static关键字，一般是怎么用？”

一句话：

Static是“类级别的”，不是“实例级别的”。

被Static修饰的东西，属于整个类，所有实例共用一份，不用new对象就能直接用；

而没被Static修饰的东西，属于单个实例，每个实例有自己的一份，必须new对象才能用。

对比项	静态（Static）	实例（非Static）
归属	属于整个类	属于单个实例
内存位置	方法区（JDK8 之后叫元空间）	堆内存
访问方式	类名.（变量/方法），或（实例.变量/方法）（不推荐）	必须通过实例.变量/方法访问
共享性	所有实例共用一份	每个实例有自己的一份
初始化时机	类加载时初始化	创建实例时初始化
访问限制	只能直接访问静态成员	可以访问静态成员和实例成员

1. 静态变量

静态变量就像是整个类共享的“公共储物柜”，所有实例共用这一个柜子，你放进去的东西，别人也能拿到；而实例变量是每个实例自己的“私人储物柜”，互不干扰。

举个例子，用静态变量做全局计数器

/**
 * 网站访问计数器
 */
public class WebsiteCounter {
    // 静态变量：所有实例共用，统计总访问次数
    public static int totalVisitCount = 0;
    // 实例变量：每个实例自己的，统计单个用户的访问次数
    public int userVisitCount = 0;

    /**
     * 访问方法
     */
    public void visit() {
        // 修改静态变量：总访问次数+1
        totalVisitCount++;
        // 修改实例变量：单个用户访问次数+1
        userVisitCount++;
    }

    public static void main(String[] args) {
        // 用户1访问
        WebsiteCounter user1 = new WebsiteCounter();
        user1.visit();
        user1.visit();
        System.out.println("用户1访问次数：" + user1.userVisitCount); // 输出2
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出2

        // 用户2访问
        WebsiteCounter user2 = new WebsiteCounter();
        user2.visit();
        System.out.println("用户2访问次数：" + user2.userVisitCount); // 输出1
        System.out.println("总访问次数：" + WebsiteCounter.totalVisitCount); // 输出3
    }
}

2. 静态方法

静态方法是属于类的“公共工具”，不用new对象，直接通过【类名.方法名】就能调用，而实例方法是属于单个实例的，必须new对象之后才能调用。

举个例子，用静态方法做工具类

/**
 * 字符串工具类
 */
public class StringUtils {
    // 私有构造方法：从根源上禁止外部代码 new StringUtils()
    // 工具类全是静态方法，完全不需要实例化，这样做能强制大家用[类名.方法名]的正确用法
    private StringUtils() {}

    /**
     * 静态方法：判断字符串是否为空
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    /**
     * 静态方法：字符串反转
     */
    public static String reverse(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return new StringBuilder(str).reverse().toString();
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法，不用new对象
        System.out.println(StringUtils.isEmpty("")); // 输出true
        System.out.println(StringUtils.reverse("hello")); // 输出olleh
    }
}

3. 静态代码块

静态代码块是类加载的时候执行一次，且只执行一次的代码块，用来初始化静态变量或者做一些类级别的准备工作（比如加载配置文件、初始化数据库连接池）。

举个例子，用静态代码块初始化静态配置

/**
 * 配置类
 */
public class Config {
    // 静态变量：数据库连接地址
    public static String dbUrl;
    public static String dbUsername;
    public static String dbPassword;

    // 静态代码块：类加载时执行一次，初始化静态变量
    static {
        System.out.println("静态代码块执行，开始初始化配置...");
        // 模拟从配置文件读取配置
        dbUrl = "jdbc:mysql://localhost:3306/test";
        dbUsername = "root";
        dbPassword = "123456";
    }

    // 实例代码块：创建实例时执行，每次new都执行
    {
        System.out.println("实例代码块执行...");
    }

    // 构造方法：创建实例时执行，每次new都执行
    public Config() {
        System.out.println("构造方法执行...");
    }

    public static void main(String[] args) {
        // 第一次访问Config类，触发类加载，静态代码块执行
        System.out.println("数据库地址：" + Config.dbUrl);
        System.out.println("---");
        // new第一个实例，实例代码块和构造方法执行
        new Config();
        System.out.println("---");
        // new第二个实例，实例代码块和构造方法执行，但静态代码块不再执行
        new Config();
    }
}

小贴士

静态代码块只在类第一次被加载时执行一次，之后不管new多少个实例，都不会再执行。

4. 静态内部类

静态内部类是属于外部类的“独立房间”，不用依赖外部类的实例就能直接创建，而非静态内部类是属于外部类实例的“附属房间”，必须先有外部类实例才能创建。

静态内部类的作用是：

利用 Java 的类加载时机，实现了懒加载（用的时候才创建）+ 线程安全（JVM 保证）+ 不用加锁（性能高）的完美单例。

举个例子，用静态内部类实现线程安全的单例模式

/**
 * 单例模式：静态内部类实现
 */
public class Singleton {
    // 私有构造方法：从根源上禁止外部代码直接 new Singleton()
    private Singleton() {}

    // 静态内部类：只有第一次被访问时才会加载（实现懒加载，用的时候才创建实例，不占内存）
    // 因为是在 Singleton 类内部，所以可以访问上面的 private 构造方法
    private static class SingletonHolder {
        // 静态变量：JVM 类加载过程是天然线程安全的，这里初始化唯一的单例实例（不用加锁，性能高）
        private static final Singleton INSTANCE = new Singleton();
    }

    // 全局唯一的访问点：外部代码只能通过这里获取单例实例
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) {
        // 获取单例实例
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        // 两个实例是同一个，完美实现单例
        System.out.println(instance1 == instance2); // 输出true
    }
}

小贴士

静态变量存放在JVM的方法区（元空间），不是堆内存。
静态变量可以通过【类名.变量名】直接访问，也可以通过【实例.变量名】访问（不过，不推荐，因为容易混淆）。
因为所有线程共用同一个静态变量，多线程同时修改会出现并发问题，需要加锁保证线程安全。
因为实例变量和方法依赖具体的实例，静态方法调用时可能还没new对象，所以，静态方法只能直接访问静态变量和静态方法，不能直接访问实例变量和实例方法。
this 代表当前实例，静态方法属于类，调用时可能还没创建实例，this 根本不存在，所以，静态方法不能用 this。
静态内部类只能直接访问外部类的静态变量和静态方法，不能直接访问实例变量和实例方法。

【面试真题拆解】你知道ThreadLocal是什么吗

Sat, 21 Mar 2026 17:34:29 +0000

ThreadLocal 是线程专属的本地变量，它的设计是给每个线程创建一份独立的变量副本，线程之间完全不共享数据，天然实现线程隔离，全程无锁竞争，性能远高于加锁保证线程安全的方案。

每个 Thread 内部都有一个专属的成员变量 ThreadLocalMap（不是 ThreadLocal 的！），Key 是 ThreadLocal 实例本身（弱引用），Value 是存的变量（强引用）。

官话太多，直接上例子。

以用户上下文传递举个例子

/**
 * 用户上下文工具类
 * 用ThreadLocal存当前登录用户的ID，避免层层传参
 */
public class UserContextHolder {
    // 定义ThreadLocal，存用户ID
    private static final ThreadLocal<Long> USER_ID_THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 设置用户ID
     */
    public static void setUserId(Long userId) {
        USER_ID_THREAD_LOCAL.set(userId);
    }

    /**
     * 获取用户ID
     */
    public static Long getUserId() {
        return USER_ID_THREAD_LOCAL.get();
    }

    /**
     * 必须手动调用！清理ThreadLocal，防止内存泄漏
     */
    public static void clear() {
        USER_ID_THREAD_LOCAL.remove();
    }
}

和加锁保证线程安全的区别

对比项	加锁	ThreadLocal
思想	多线程排队用同一个变量，保证同一时间只有一个线程能访问	每个线程用自己的专属变量，完全不共享
性能	有锁竞争，高并发下性能差	无锁竞争，性能高
适用场景	多线程必须共享同一个变量的场景（比如共享计数器、共享资源修改）	每个线程需要独立变量副本的场景（比如用户上下文、SimpleDateFormat 线程安全）

小贴士

很多人以为ThreadLocalMap的Key是“线程ID”，其实Key是ThreadLocal实例本身，而不是线程ID。

一个线程可以有多个ThreadLocal实例，每个实例对应一个Value，存到同一个ThreadLocalMap里，Key不同，互不干扰。

ThreadLocal内存泄漏问题

Java中的4种引用强度

强引用

我们平时写的 Object obj = new Object() 就是强引用，只要强引用还在，GC就不会回收这个对象。

软引用

用 SoftReference 包装的引用，只有当内存不够用的时候，GC 才会回收这个对象。

弱引用

用 WeakReference 包装的引用，只要GC一运行，不管内存够不够，都会回收这个对象。

虚引用

用 PhantomReference 包装的引用，完全不影响对象的生命周期，只是用来在对象被 GC 回收前收到一个通知，做一些收尾工作。

ThreadLocalMap的Entry结构

ThreadLocalMap的Entry是继承自WeakReference的，结构如下：

static class Entry extends WeakReference<ThreadLocal<?>> {
    Object value;
    Entry(ThreadLocal<?> k, Object v) {
        super(k); // Key是弱引用
        value = v; // Value是强引用
    }
}

假设创建了一个 ThreadLocal 实例，有外部强引用指向它，同时把它作为 Key 存到了线程的 ThreadLocalMap 里；

当用完 ThreadLocal 后，没有手动 remove，而且外部的强引用也没了（比如 threadLocal = null），因为 Key 是弱引用，GC 一运行，Key 就被回收了，变成了 null。

但是， Value 是强引用，只要线程还活着，Value 就不会被 GC 回收，这就导致了内存泄漏。

更严重的还有，如果用了线程池，线程会被长期复用，不仅内存泄漏，还会导致用户信息串号、数据错误等严重的业务问题。

怎么避免内存泄漏

使用完ThreadLocal后，手动调用 remove() 方法。

举个例子，在Spring Boot的拦截器里：

@Component
public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从Token里解析出用户ID，存到ThreadLocal
        Long userId = parseUserIdFromToken(request.getHeader("Authorization"));
        UserContextHolder.setUserId(userId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 在这里清理，不管请求成功失败，都要清理。
        UserContextHolder.clear();
    }
}

【面试真题拆解】Spring事务机制

Fri, 20 Mar 2026 09:06:26 +0000

之前面试的时候还真的有一个面试官问过我：

什么是事务？

事务，说人话就是：

把多个数据库操作打包成一个“不可分割的整体”，要么全成功，要么全失败并回滚到最初状态，绝对不会出现“只做了一半”的情况。

以生活中最经典的银行转账举个例子那是再合适不过了。

且看：

A给B转100块钱，这一笔转账业务，其实是由两步独立的数据库操作组成的：

A的账户扣100块

B的账户加100块

这两步必须同时成功、一起生效。

如果A扣了钱B没收到，或者B收到了钱A没扣，那银行就乱套了。

事务的四大特性

用银行转账的例子加深理解：

特性	解释	银行转账例子
原子性（Atomicity）	要么全做，要么全不做，就像“原子”一样不可分割	A扣钱和B加钱必须同时成功，不能A扣了B没加
一致性（Consistency）	事务前后，数据要保持“一致”，总金额不变	转账前A有1000，B有0，总和是1000；转账后A有900，B有100，总和还是1000
隔离性（Isolation）	多个事务同时执行时，互相不干扰，就像“隔离开”一样	两个转账操作同时改A的账户，不能互相影响，不然钱就不对了
持久性（Durability）	事务提交后，数据就永久保存了，就算数据库挂了也不会丢	转账成功后，就算银行服务器断电重启，A和B的钱数也不会变

隔离级别

为什么要有隔离级别呢？

如果多个事务同时执行，没有隔离的话，会出现3个问题：

脏读

脏读就是读到了别人还没提交的数据。

比如A转给B100块，还没提交，B就查到自己多了100块，结果A回滚了，B白高兴一场。

不可重复读

不可重复读的意思是同一个事务里，两次读同一条数据的结果是不一样的。

比如A查自己有1000块，中间B转给了A100块提交了，A再查就变成1100了。

幻读

幻读就是同一个事务里，两次查的数量不一样。

比如A查账户里有10条记录，中间B插了一条提交了，A再查就变成11条了，就像“幻觉”一样。

这么看，不可重复读和幻读是由别的事务提交后导致的错误，而脏读是读到了别人还没提交的临时数据。

那不可重复读和幻读两者的区别在哪呢？

不可重复读是盯着一条记录看，发现这条记录的内容变了。

而幻读是盯着一堆记录数看，发现总数量变了。

类比一下就是不可重复读是你看自己的银行卡余额，钱数变了；而幻读是你数银行有多少张卡，卡的数量变了。

隔离级别	解决的问题	解释
读未提交（Read Uncommitted）	啥都解决不了	能读到别人没提交的数据，脏读、不可重复读、幻读都有，一般不用
读已提交（Read Committed）	脏读	只能读到别人提交后的数据，但会有不可重复读、幻读
可重复读（Repeatable Read）	脏读、不可重复读	Spring默认的隔离级别。同一个事务里，两次读同一个数据一样，但会有幻读（MySQL InnoDB用MVCC解决了幻读）
串行化（Serializable）	所有问题	事务一个接一个执行，就像“排队”一样，性能最差，一般不用

传播行为

传播行为就是：

当一个事务方法调用另一个事务方法时，这两个事务该怎么协作？是直接加入原事务？还是新建一个独立的事务？还是先挂起原事务，等新事务执行完再继续？

以下是3 个常用的传播行为:

传播行为	解释	适用场景
REQUIRED（默认）	有事务就加入，没有就新建一个事务	最常用，比如转账服务
REQUIRES_NEW	新建一个事务，挂起原事务，等新事务执行完再继续原事务	比如记录日志，不管主事务成功失败，日志都要记录
NESTED	嵌套事务，有一个保存点： 1. 子事务回滚：只回滚自己，不影响父事务和其他子事务 2. 父事务回滚：带着所有子事务一起回滚	系统批量发福利：某一个用户的福利发放失败，不影响其他用户；但整体回滚，所有用户的福利都会被收回

小贴士

Spring AOP 是基于代理的，@Transactional 只能用在 public 方法上，不然不生效。不管是 JDK 动态代理还是 CGLIB 代理，Spring 都只保证 public 方法的事务生效，非 public 的写了也白写。
内部调用不会走代理类，直接调用this.method()，所以，同一个类里方法调用，@Transactional不生效。
Spring默认只回滚非受检异常（RuntimeException、Error），受检异常（Exception）不回滚。如果要所有异常都回滚，需要在 @Transactional 里加rollbackFor = Exception.class。
MySQL的MyISAM引擎不支持事务，只有InnoDB支持。

23种设计模式，一次性讲明白

Thu, 19 Mar 2026 12:50:01 +0000

设计模式其实就是前辈们写代码踩了无数坑，总结出来的代码编写最佳实践，专门用来解决特定场景下的代码复用、解耦、扩展性问题。

可以分为创建型模式、结构型模式、行为型模式三类。

分类	核心作用	包含的设计模式	数量
创建型模式	解决对象怎么创建的问题，解耦对象的创建和使用	单例、工厂方法、抽象工厂、建造者、原型	5种
结构型模式	解决类/对象怎么组合的问题，不修改原有代码实现功能扩展	适配器、桥接、组合、装饰、外观、享元、代理	7种
行为型模式	解决类/对象之间怎么交互、职责怎么分配的问题，实现灵活的通信和流程控制	模板方法、命令、迭代器、观察者、中介者、备忘录、解释器、状态、策略、职责链、访问者	11种

记忆口诀

创建型口诀（5种）

单身汉在工厂抽象建原型。

一个单身汉，在工厂里用抽象方法，建造了一个原型。

结构型口诀（7种）

桥上代理卖装饰，组合适配享外观。

桥上的代理商在卖装饰品，把零件组合适配好，让你享受精美外观。

行为型口诀（11种）

访客观察定策略，模板迭代改状态，备忘命令交中介，解释责任一条链。

访客观察后定下策略，按模板迭代改变状态，把备忘录和命令交给中介，出了问题沿责任链逐一解释。

创建型模式

不让你自己new对象，把对象创建的逻辑封装起来，和业务代码解耦。

1. 单例模式

整个系统里，这个类有且只有一个实例对象，不管你在哪获取，拿到的都是同一个东西。

类比

就像公司里只有一个 CEO，不管哪个部门找，对接的都是同一个人。

适用场景

Spring容器里的单例Bean、全局配置类、日志对象

代码示例

public class Singleton {
    // 1. 私有构造方法：禁止外部new对象
    private Singleton() {}

    // 2. 私有静态实例，volatile禁止指令重排
    private static volatile Singleton instance;

    // 3. 公共静态方法，获取唯一实例
    public static Singleton getInstance() {
        // 第一次校验：实例已存在就直接返回，不用抢锁
        if (instance == null) {
            // 加锁，保证线程安全
            synchronized (Singleton.class) {
                // 第二次校验：防止多线程同时进入第一个if，重复创建
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂方法模式

定义一个创建对象的工厂接口，让子类决定创建哪个对象，把对象的创建延迟到子类。

类比

就像奶茶店是工厂接口，蜜雪冰城、喜茶是子类工厂，你去哪个店，就喝哪个店的奶茶，不用管奶茶是怎么做的。

适用场景

不知道要创建的对象具体类型，交给子类决定
把对象创建和业务代码解耦
Spring的FactoryBean

代码示例

// 1. 产品接口：奶茶
public interface MilkTea {
    void make();
}

// 2. 具体产品：蜜雪冰城奶茶
public class MixueMilkTea implements MilkTea {
    @Override
    public void make() {
        System.out.println("蜜雪冰城奶茶做好了！");
    }
}

3. 抽象工厂模式

工厂方法的升级版，一个工厂可以创建一系列相关的产品，而不是只创建一个。

和工厂方法的区别是：

工厂方法是单个产品，而抽象工厂是一套相关产品。

类比

就像蜜雪冰城不仅能做奶茶，还能做冰淇淋、圣代，一个工厂搞定同品牌的一系列产品。

适用于需要创建一系列相关联的产品，而不是单个产品的场景（比如同一品牌的奶茶 + 冰淇淋 + 圣代）。

4. 建造者模式

把一个复杂对象的创建和表示分离，一步一步构建出复杂对象，不用管内部组装细节。

类比

就像组装电脑，你只需要告诉装机店你要什么 CPU、显卡、内存，装机店帮你一步步组装好，不用你自己焊主板。

适用场景

复杂对象的创建，参数特别多（比如超过4个参数）
Lombok的@Builder注解

代码示例

// 电脑类（复杂对象）
public class Computer {
    private String cpu;
    private String gpu;
    private int memory;
    private int storage;

    // 私有构造方法，只能通过Builder创建
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.gpu = builder.gpu;
        this.memory = builder.memory;
        this.storage = builder.storage;
    }

    // 建造者静态内部类
    public static class Builder {
        private String cpu;
        private String gpu;
        private int memory;
        private int storage;

        // 链式调用设置参数
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Builder memory(int memory) {
            this.memory = memory;
            return this;
        }

        public Builder storage(int storage) {
            this.storage = storage;
            return this;
        }

        // 构建最终对象
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        // 链式调用，一步一步构建对象
        Computer computer = new Computer.Builder()
                .cpu("i7-14700K")
                .gpu("RTX4070")
                .memory(32)
                .storage(1024)
                .build();
    }
}

5. 原型模式

基于一个已有的对象，克隆出一个一模一样的新对象，不用重新new和初始化。

类比

就像打印机复印文件，不用重新手写一遍，直接复印一份一模一样的。

适用场景

对象创建成本很高（比如初始化要查数据库、调接口）
想要和原对象一模一样的新对象，又不想重新初始化
Spring的Bean的原型作用域

就像出行，你可以选骑自行车、坐地铁、开车、坐飞机，这些都是不同的出行策略，你可以根据目的地、预算随便换，不用改变你要出门的目标。

适用场景

一个业务有多种实现方式，需要动态切换
想要避免大量的if-else/switch分支
Spring的Resource接口、BeanNameGenerator

代码示例

// 1. 策略接口：出行方式
public interface TravelStrategy {
    void travel();
}

// 2. 具体策略：坐地铁
public class SubwayStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("坐地铁出行，便宜又快");
    }
}

// 3. 具体策略：开车
public class CarStrategy implements TravelStrategy {
    @Override
    public void travel() {
        System.out.println("开车出行，自由方便");
    }
}

// 4. 用户
public class Traveler {
    private TravelStrategy strategy;

    // 动态设置策略
    public void setStrategy(TravelStrategy strategy) {
        this.strategy = strategy;
    }

    // 执行出行
    public void goTravel() {
        strategy.travel();
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Traveler traveler = new Traveler();
        // 今天坐地铁
        traveler.setStrategy(new SubwayStrategy());
        traveler.goTravel();
        // 明天开车
        traveler.setStrategy(new CarStrategy());
        traveler.goTravel();
    }
}

2. 观察者模式

定义了对象之间一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。

类比

就像你关注了一个CSDN博主，博主更新博客了，所有关注他的粉丝都会收到推送通知。

适用场景

事件驱动、消息通知、发布订阅
Spring的ApplicationEvent事件机制
Java的EventListener

适用场景

对象的行为由状态决定，运行时状态变化会改变行为
代码里有大量和状态相关的if-else/switch分支

小贴士

状态模式和策略模式容易混淆，不过两者的区别是：

状态模式是状态决定行为，对象的行为由当前状态决定；而策略模式是算法可替换，封装一系列平级算法，想换哪个换哪个。
状态模式有明确的状态流转图，状态之间不能随便跳，必须按规则流转；策略模式没有流转关系，策略之间是平级的，想换就换。
状态模式关注的是对象状态的变化以及状态变化带来的行为变化；策略模式关注的是算法的选择和替换，不关心算法之间的关系。

扯了那么多官话，好像没多大用，举个例子套一下大概就是：

比如电梯是状态模式，开门、上下行、关门有明确的流转规则；

撤销、回滚操作
数据库的事务回滚
IDE的撤销操作

10. 访问者模式

在不修改数据结构的前提下，定义对数据结构中元素的新操作，把数据结构和操作分离。

类比

比如电商订单系统，数据结构是固定的订单和订单明细，操作是经常变化的计算总价、打印发票、生成物流单、发送短信通知。不用修改订单 / 订单明细的代码，只要新增一个访问者（比如生成电子发票），就能给订单增加新操作。

适用于想要给数据结构里的元素增加新操作，又不想修改数据结构的场景。

11. 解释器模式

给定一个语言，定义它的语法规则，然后定义一个解释器，用这个解释器来解释语言中的句子。

类比

就像翻译官，你说中文，翻译官根据中英文的语法规则，把你的话翻译成英文。

适用场景

SQL解析、正则表达式解析
Spring的SpEL表达式

【面试真题拆解】Java文件操作的异常类型与受检_非受检异常

Tue, 17 Mar 2026 21:09:31 +0000

以往面试的时候问Java异常好像背一背题就行，但是这个面试官水平还是很高的，换了一种问法，大概是这么问的：

Java中写了一个函数，打开了一个文件，读这个文件然后关闭，中间没有写try-catch，保存之后，编辑器自动在这个函数声明后面加了throws exception，你觉得这些exception会有哪些呢？

如果把这个函数进行修改，不读写文件，只进行简单的数据处理，这时保存之后，发现函数声明的后面没有throws这些异常了，在这种情况下是不是就不会抛出异常了？

有点懵了，完犊子。。。

主要有以下几点，掌握了应该问题不大：

文件操作的异常主要是IOException及其子类，属于受检异常，必须显式处理（要么 try-catch，要么 throws）；

简单数据处理的异常多是RuntimeException 及其子类（如空指针、数组越界），属于非受检异常，无需强制 throws 或 try-catch；

受检异常要求“编译时必须处理”，非受检异常是“运行时才可能出现”，编译器不强制要求。

文件操作会抛出哪些异常？

复现一下面试题里的场景：

写一个文件读写函数，没加 try-catch，编辑器自动加了 throws Exception。

import java.io.*;

public class FileReadExample {
    // 编辑器自动加了 throws Exception，因为里面有受检异常
    public void readFile(String filePath) throws Exception {
        // 1. 打开文件流
        FileInputStream fis = new FileInputStream(filePath);
        // 2. 读取文件内容
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
        // 3. 关闭文件流
        fis.close();
    }
}

有以下几种文件操作中常见的异常

异常类型	触发场景
FileNotFoundException	文件路径不存在、文件是目录、没有读权限
IOException	读取文件时IO错误（如磁盘损坏、网络文件系统（NFS）的连接意外中断）
EOFException	读取到文件末尾仍尝试读取

小贴士：

FileNotFoundException 是 IOException 的子类，如果 throws IOException，也能覆盖 FileNotFoundException。

为什么简单数据处理不需要 `throws`？

面试题里的第二个场景：

把函数改成只做简单数据处理，编辑器就不加 throws 了。

复现一下这个场景：

public class SimpleDataProcessExample {
    // 编辑器不会加 throws，因为里面都是非受检异常
    public void processData(int[] arr, String str) {
        // 1. 数组越界：ArrayIndexOutOfBoundsException（非受检）
        int num = arr[10];
        // 2. 空指针：NullPointerException（非受检）
        int len = str.length();
        // 3. 非法参数：IllegalArgumentException（非受检）
        if (arr.length == 0) {
            throw new IllegalArgumentException("数组不能为空");
        }
    }
}

这里的主要原因是：

简单数据处理的异常都是 RuntimeException 的子类，是非受检异常，编辑器不会强制要求 throws 或 try-catch。

受检异常 vs 非受检异常

对比维度	受检异常（Checked Exception）	非受检异常（Unchecked Exception）
定义	编译时必须处理的异常，不处理编译不通过	运行时才可能出现的异常，编译器不强制要求处理
所属类	`Exception` 及其子类（除了 `RuntimeException` 及其子类）	`RuntimeException` 及其子类、`Error` 及其子类
典型例子	`IOException`、`FileNotFoundException`	`NullPointerException`、`ArrayIndexOutOfBoundsException`、`IllegalArgumentException`
处理要求	必须 `try-catch` 或 `throws`	可以不处理，也可以处理
设计目的	提醒开发者“这里可能有外部不可控的错误，必须处理”	提醒开发者“这里有代码逻辑错误，需要修复代码”

实际开发中，文件操作的异常怎么处理？

不要直接 throws Exception，推荐显式抛出具体异常（如 throws IOException）或者 try-catch 处理，记录日志并给出友好提示。

举个例子：

public void readFile(String filePath) {
    FileInputStream fis = null;
    try {
        fis = new FileInputStream(filePath);
        byte[] buffer = new byte[1024];
        int len = fis.read(buffer);
    } catch (FileNotFoundException e) {
        System.err.println("文件不存在：" + filePath);
        e.printStackTrace();
    } catch (IOException e) {
        System.err.println("文件读取失败");
        e.printStackTrace();
    } finally {
        // 必须在 finally 里关闭流，防止内存泄漏
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

前后端分离+微服务架构下的用户认证

Tue, 17 Mar 2026 19:38:35 +0000

先明确一些核心组件：

组件	作用
前端	页面展示、用户交互、存储Token
API网关	统一入口、路由转发、Token校验
认证中心	用户登录验证、生成/刷新Token
微服务	处理业务逻辑、获取用户信息
数据库	存储用户账号密码、权限信息

当时面试官跟我说，你可以从前端打开一个页面开始讲。

那我们就举个例子：

以用户打开一个电商网站首页➡️跳转登录➡️输入账号密码登录➡️携带Token请求商品列表为例，说一下这个完整的流程。

1.前端打开页面，检查本地是否有Token

用户在浏览器输入 https://www.example.com，前端代码首先检查本地存储中是否存在有效的Token。

2.没有Token，前端跳转登录页，用户输入账号密码

如果本地没有Token，前端路由跳转到 /login 登录页，用户输入账号和密码，点击【登录】按钮。

3.前端发送登录请求到API网关

前端将账号密码封装成POST请求，发送到API网关。

需要注意的是：前端不直接请求认证中心，所有请求都走网关统一入口。

4.API网关转发登录请求到认证中心

API网关收到 /auth/login 请求，根据路由规则，将请求转发到认证中心服务。

5.认证中心验证用户信息，生成JWT Token

认证中心做以下3件事：

从数据库查询用户信息，验证账号密码是否正确；
验证通过后，生成 JWT Token（分为 Access Token 和 Refresh Token）；
将 Token 返回给前端。

那什么是JWT呢？

JWT（JSON Web Token）是一种无状态的Token，由三部分组成，用 . 分隔：

Header：头部，存算法和类型；
Payload：载荷，存用户信息（比如userId、username、过期时间）；
Signature：签名，用密钥对Header和Payload签名，防止Token被篡改。

6.前端收到Token，存储到本地

前端收到认证中心返回的 access_token 和 refresh_token，存到本地存储中。

7.前端携带Token请求业务接口

用户登录成功后，前端请求商品列表接口，在请求头 Authorization 中携带 Bearer Token。

Bearer 这个单词的意思是“持票人”、“持有者”。

Bearer Token 就是：“谁持有这个 Token，谁就是合法的访问者，服务器就认谁”。

8.API网关校验Token

API网关收到 /product/list 请求，通过全局过滤器校验Token的有效性：

从请求头 Authorization 中取出Token；
验证Token的签名是否正确；
验证Token是否过期；
校验通过后，将用户信息（比如userId）放入请求头，转发给微服务；
如果校验失败，直接返回401未授权。

9.微服务获取用户信息，处理业务逻辑

微服务（比如商品服务）收到网关转发的请求，从请求头 X-User-Id 中取出userId，处理业务逻辑（比如查询该用户的商品列表）。

10.Token过期，前端用Refresh Token刷新

Access Token有效期比较短（比如只有2小时），过期后前端请求会收到401；

此时前端不用让用户重新登录，而是用Refresh Token去认证中心刷新Access Token。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

只有一个线程多次获取同一把锁，没有其他线程竞争。
第一个线程获取锁时，会在对象头的 Mark Word 里记录【偏向线程ID】，这个线程以后再次获取锁时，只需要检查偏向线程ID是不是自己，如果是，直接获取锁。
当有第二个线程来竞争这把锁时，偏向锁会撤销，升级为轻量级锁。

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

线程在自己的栈帧里创建一个锁记录（Lock Record），用 CAS（Compare And Swap，比较并交换）操作，尝试把对象头的 Mark Word 替换成指向自己栈中锁记录的指针。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Java锁机制：synchronized、ReentrantLock、锁升级、可重入锁

Tue, 17 Mar 2026 13:23:22 +0000

一句话速通：

Java 锁机制核心是 synchronized 和 ReentrantLock，两者都是可重入锁；

JDK 1.6+ 后 synchronized 引入锁升级（无锁➡️偏向锁➡️轻量级锁➡️重量级锁），性能大幅提升；

简单场景优先用 synchronized，需要高级功能（比如可中断、可超时、公平锁）时用 ReentrantLock。

为什么需要锁？

在并发场景下，多个线程同时修改同一个共享变量，会出现线程安全问题。

举个例子说明一下：

public class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这行代码不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

如果1000个线程同时调用 increment()，最终 count 的值很可能小于1000。

因为 count++ 不是原子操作，它分为读取count、count+1、写回count三步，多线程同时执行会互相覆盖。

锁的作用就是把这段代码加锁，让同一时间只有一个线程能执行，从而保证操作的原子性。

synchronized

synchronized 是JVM内置的关键字，不需要手动释放锁。

用法	锁的对象	示例
锁实例方法	锁当前对象 `this`	`public synchronized void increment()`
锁静态方法	锁当前类的 `Class` 对象	`public static synchronized void increment()`
锁代码块	锁指定的对象	`synchronized (lock) { ... }`

可以用synchronized给之前的例子上锁：

public class SafeCounter {
    private int count = 0;

    // 锁实例方法：同一时间只有一个线程能执行
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock

ReentrantLock 是 java.util.concurrent（JUC）包下的锁，是基于代码实现的锁，比 synchronized 更灵活，但需要手动释放锁。

也可以用ReentrantLock给之前的例子上锁：

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCounter {
    private int count = 0;
    // 创建 ReentrantLock 实例
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // 加锁
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 里释放锁，防止死锁
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock 有3个 synchronized 没有的功能：

功能	说明	示例
可中断	线程在等待锁的过程中，可以被中断，停止等待	`lock.lockInterruptibly()`
可超时	尝试获取锁，等待一段时间后如果还没拿到，就放弃	`lock.tryLock(1, TimeUnit.SECONDS)`
公平锁	按线程请求锁的顺序分配锁（先来先得），默认是非公平锁	`new ReentrantLock(true)`

可重入锁

synchronized 和 ReentrantLock 都是可重入锁。

那什么是可重入呢？

可重入的意思就是同一个线程，可以多次获取同一把锁，不会被自己阻塞。

那又为什么需要可重入呢？

举个递归调用的例子：

public class ReentrantExample {
    //  synchronized 是可重入的
    public synchronized void methodA() {
        System.out.println("执行 methodA");
        methodB(); // 调用 methodB，methodB 也需要同一把锁
    }

    public synchronized void methodB() {
        System.out.println("执行 methodB");
    }

    public static void main(String[] args) {
        ReentrantExample example = new ReentrantExample();
        example.methodA();
    }
}

如果锁是不可重入的，那么线程在执行 methodA() 时已经拿到了锁，调用 methodB() 时会因为拿不到锁而被自己阻塞，导致死锁。

synchronized 的锁升级

在 JDK 1.6 之前，synchronized 是重量级锁，性能很差；

JDK 1.6 之后，引入了锁升级机制，提升了 synchronized 的性能。

锁升级的意思是：

随着多线程竞争的加剧，锁会从【无锁】➡️【偏向锁】➡️【轻量级锁】➡️【重量级锁】逐步升级，而且升级是单向的，只能升不能降。

Java对象在内存中分为3部分：

对象头、实例数据、对齐填充，其中对象头里的 Mark Word 会记录锁的状态。

而synchronized 的锁是存放在【对象头】里的。

Mark Word 的结构（32 位 JVM）：

锁状态	25位	4位	1位（是否偏向锁）	2位（锁标志位）
无锁	对象的哈希码	分代年龄	0	01
偏向锁	偏向线程ID	分代年龄	1	01
轻量级锁	指向栈中锁记录的指针			00
重量级锁	指向重量级锁（monitor）的指针			10

锁升级的四个阶段

1. 无锁

没有线程竞争锁，对象处于无锁状态。

2. 偏向锁

3. 轻量级锁

多个线程交替获取锁，但是竞争不太激烈（比如线程A获取锁，执行完释放了，线程B再获取）。

如果 CAS 成功，就获取到了轻量级锁。

当有多个线程同时竞争锁，CAS 失败多次，就会升级为重量级锁。

4. 重量级锁

多个线程同时竞争锁，竞争激烈。
锁升级为重量级锁后，对象头的 Mark Word 会指向一个monitor（监视器）对象。

没有获取到锁的线程会进入阻塞队列，被操作系统挂起，等待持有锁的线程释放锁后唤醒。

【面试真题拆解】Java字节流、字符流

Mon, 16 Mar 2026 10:00:59 +0000

Java IO流的分类

Java IO流主要从两个维度分类：

分类维度	分类结果	说明
按数据流向分	输入流（Input）	从磁盘/网络/内存「读」数据到程序
	输出流（Output）	从程序「写」数据到磁盘/网络/内存
按处理单元分	字节流（Byte Stream）	以「字节（byte）」为单位处理数据，是万能流
	字符流（Character Stream）	以「字符（char）」为单位处理数据，专门处理文本

字节流

什么是字节流？

计算机里所有数据（图片、视频、音频、文本、PDF）本质上都是字节（0和1的组合），所以字节流是万能流，可以处理任何类型的数据。

字节流的核心类

字节流的抽象基类是 InputStream（输入流）和 OutputStream（输出流），开发中最常用的是它们的子类：

类名	作用
`FileInputStream`	从文件中读取字节
`FileOutputStream`	向文件中写入字节
`BufferedInputStream`	带缓冲的字节输入流，提升读性能
`BufferedOutputStream`	带缓冲的字节输出流，提升写性能

举个例子

字节流典型的应用——复制非文本文件（图片、视频、PDF）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        // 源文件路径（一张图片）
        String srcPath = "C:/test/photo.jpg";
        // 目标文件路径
        String destPath = "C:/test/photo_copy.jpg";

        // 用try-with-resources自动关闭流，避免内存泄漏
        try (
            // 1. 创建文件字节输入流：从源文件读字节
            FileInputStream fis = new FileInputStream(srcPath);
            // 2. 创建文件字节输出流：向目标文件写字节
            FileOutputStream fos = new FileOutputStream(destPath)
        ) {
            // 3. 定义一个字节数组作为缓冲区（一次读1024字节，即1KB，提升性能）
            byte[] buffer = new byte[1024];
            int len; // 记录每次实际读到的字节数

            // 4. 循环读写：fis.read(buffer)返回-1表示读到文件末尾
            while ((len = fis.read(buffer)) != -1) {
                // 只写实际读到的len个字节，避免最后一次写多余的空字节
                fos.write(buffer, 0, len);
            }
            System.out.println("图片复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

什么是字符流？

字符流是专门处理文本数据的流，它以【字符】为单位处理数据，内部会自动处理编码转换（比如把UTF-8编码的字节转成Java的char字符）。

为什么不用字节流处理文本？

因为中文等非ASCII字符占多个字节（比如UTF-8编码的中文占3个字节）。

如果用字节流读，可能会把一个汉字的3个字节截断，从而导致乱码；

而字符流会自动识别编码，按字符读取，不会乱码。

字符流的核心类

字符流的抽象基类是 Reader（输入流）和 Writer（输出流），开发中最常用的是它们的子类：

类名	作用
`FileReader`	从文件中读取字符
`FileWriter`	向文件中写入字符
`BufferedReader`	带缓冲的字符输入流
`BufferedWriter`	带缓冲的字符输出流
`InputStreamReader`	转换流：字节流转字符流
`OutputStreamWriter`	转换流：字符流转字节流

举个例子

BufferedReader的readLine()方法可以按行读取文本，非常方便。

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

public class CharacterStreamExample {
    public static void main(String[] args) {
        String filePath = "C:/test/中文文章.txt";

        // 用转换流InputStreamReader，显式指定UTF-8编码，避免乱码
        try (
            // 1. 先创建字节输入流
            FileInputStream fis = new FileInputStream(filePath);
            // 2. 用转换流把字节流转成字符流，显式指定UTF-8编码
            InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
            // 3. 用缓冲流包装，提升性能，且有readLine()方法
            BufferedReader br = new BufferedReader(isr)
        ) {
            String line;
            int lineNum = 1;
            // readLine()返回null表示读到文件末尾
            while ((line = br.readLine()) != null) {
                System.out.println("第" + lineNum + "行：" + line);
                lineNum++;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

【面试真题拆解】Java类加载过程+双亲委派机制

Sun, 15 Mar 2026 22:44:04 +0000

什么是类加载？

简单来说，类加载就是把.class文件（编译后的字节码）从磁盘/网络加载到JVM内存里，并生成对应的Class对象的过程。

Java类加载的5个核心阶段

类加载不是一步到位的，而是分成了5个阶段： 加载➡️验证➡️准备➡️解析➡️初始化，其中加载、验证、准备、初始化的顺序是固定的，解析可能在初始化之后（为了支持动态绑定）。

1. 加载（Loading）

这是类加载的第一步，举个例子：假如你要加载User类，JVM会先找到User.class文件，把它的信息存到方法区，然后在堆里生成一个Class对象，以后你要访问User类的信息，都通过这个Class对象。

2. 验证（Verification）

这一步是为了保证JVM的安全，防止恶意或不规范的.class文件搞破坏，主要验证四个方面：

文件格式验证：检查.class文件的魔数（开头的CAFEBABE）、版本号（JDK版本兼容）等；
元数据验证：检查类的继承关系（比如不能继承final类）、方法重写是否合法等；
字节码验证：检查字节码指令是否安全（比如不会跳转到非法指令、不会访问越界的数组）；
符号引用验证：检查符号引用（比如类名、方法名）是否能找到对应的类/方法。

3. 准备（Preparation）

这一步是在方法区里为类的静态变量（static修饰的变量）分配内存，并设置初始默认值。

需要注意的是：不是代码里写的初始值，而是以下这些初始值：

数据类型	默认值
int	0
long	0L
float	0.0f
double	0.0d
boolean	false
引用类型	null

4. 解析（Resolution）

这一步是把常量池里的符号引用（比如类名com.example.User、方法名getUser），转换成直接引用（比如内存地址、指针）。

解析的话，主要针对的是类、接口、字段、方法等符号引用。

举个通俗一点的例子：

符号引用就是一个“代号”，比如你用“张三”指代一个人，不管他在哪，“张三”这个代号都能用；

而直接引用就是“具体的地址”，比如张三现在在“XX小区XX号楼XX室”，你可以直接找到他。

5. 初始化（Initialization）

这是类加载的最后一步，也是真正执行程序员写的代码的阶段。

这一步只做一件事：执行类构造器<clinit>()方法。

<clinit>()方法是编译器自动生成的，它会把类里的静态变量赋值语句和静态代码块（static {}）按顺序合并起来执行。

举个例子

public class User {
    static int num = 10; // 静态变量赋值
    static { // 静态代码块
        num = 20;
        System.out.println("静态代码块执行");
    }
}

以上代码在初始化阶段，JVM会执行<clinit>()方法：

先把num设为10，再设为20，然后打印“静态代码块执行”。

什么时候会触发类的初始化？

有以下6种情况：

创建类的实例（new User()）；
访问类的静态变量或静态方法（User.num、User.getUser()）；
用Class.forName("com.example.User")反射加载类；
初始化子类时，会先初始化父类；
JVM启动时，会先初始化包含main()方法的主类；
JDK 7+的动态语言支持，MethodHandle解析结果为REF_getStatic/REF_putStatic/REF_invokeStatic的句柄，且对应的类未初始化。

双亲委派机制（Parent Delegation Model）

什么是类加载器？

类加载器（ClassLoader）就是负责加载类的工具，JVM内置了三种类加载器：

启动类加载器（Bootstrap ClassLoader）

用C++写的，不是ClassLoader的子类，开发者无法直接获取它的引用。

负责加载JDK核心类库（比如java.lang.Object、java.lang.String），这些类在jre/lib/rt.jar里。

扩展类加载器（Extension ClassLoader）

是ClassLoader的子类，开发者可以获取它的引用，负责加载JDK扩展类库（比如jre/lib/ext目录下的类）。

应用程序类加载器（Application ClassLoader）

是ClassLoader的子类，也是默认的类加载器。负责加载用户自己写的类（比如com.example.User），也就是classpath下的类。

什么是双亲委派机制？

这里的“双亲”不是指“父母”，而是指“父类加载器”，是翻译的问题，理解成“父委派机制”更准确一点。

双亲委派机制的核心规则是：“向上委托，向下加载”

当一个类加载器收到加载类的请求时，它不会自己先加载，而是把请求委托给父类加载器去加载；
如果父类加载器能加载这个类，就由父类加载器加载；
如果父类加载器加载不了（比如在它的加载范围内找不到这个类），才会向下交给子类加载器自己加载。

举个例子

比如说：加载java.lang.Object

应用程序类加载器收到加载Object的请求，它不自己加载，委托给扩展类加载器；
扩展类加载器也不自己加载，委托给启动类加载器；
启动类加载器在rt.jar里找到了Object类，直接加载它；
加载完成，返回Class对象，不会再向下交给子类加载器。

为什么需要双亲委派机制？

双亲委派机制的目的是保证Java程序的安全性和稳定性，主要解决了两个问题：

避免类的重复加载

如果没有双亲委派，用户自己写一个java.lang.Object类，应用程序类加载器就会加载它，导致JVM里有两个Object类，程序就乱了。

保证核心类库的安全

防止用户恶意篡改核心类库（比如写一个恶意的java.lang.String类），因为核心类库只会由启动类加载器加载，用户写的同名类不会被加载。

破坏双亲委派机制的情况

常见的破坏双亲委派机制的场景：

JDBC的DriverManager

JDBC需要加载不同数据库的驱动（比如MySQL驱动），但驱动类是用户写的，启动类加载器加载不了，所以DriverManager用了线程上下文类加载器（Thread Context ClassLoader），打破了双亲委派，让启动类加载器能委托应用程序类加载器加载驱动。

Tomcat的类加载器

Tomcat需要隔离不同Web应用的类（比如两个应用都用了不同版本的Spring），所以它有自己的类加载器结构，每个Web应用有独立的类加载器，优先加载自己的类，而不是向上委托。

【面试真题】Java中什么是反射

Sat, 14 Mar 2026 12:16:58 +0000

首先，官方的定义是这样的：

Java反射（Reflection）是指在程序运行时，动态获取类的完整结构信息（如构造方法、字段、方法），并能直接操作对象的属性或方法的机制。

正射 vs 反射

用【创建对象并调用方法】举个例子：

正射

就是我们平时写代码的方式，编译期就知道要操作的类是什么，直接 new 对象调用方法：

1
2
3

// 正射：编译期就确定是User类
User user = new User();
user.setName("张三"); // 直接调用方法

反射

动态的方式**，编译期**不知道要操作的类是什么，运行期才通过类名字符串动态获取类信息并操作：

// 反射：运行期才通过字符串"com.example.User"获取类
Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance(); // 动态创建对象
Method setNameMethod = clazz.getDeclaredMethod("setName", String.class);
setNameMethod.invoke(user, "张三"); // 动态调用方法

原理

反射的底层，其实是操作JVM加载类后生成的 Class对象。

先回顾一下类的加载过程：

编译期：.java文件被编译成 .class字节码文件；
类加载期：JVM的类加载器（ClassLoader）把 .class文件加载到内存，生成一个 java.lang.Class对象（这个对象包含了类的所有结构信息）；
运行期：反射就是通过这个 Class对象，逆向获取类的构造方法、字段、方法等信息，并进行操作。

说人话就是：Class对象是反射的入口，所有反射操作都从获取Class对象开始。

手撕一下，加深理解

1. 获取Class对象的3种方式

// 方式1：类名.class（最常用，编译期就能获取）
Class<User> clazz1 = User.class;

// 方式2：对象.getClass()（已有对象时用）
User user = new User();
Class<? extends User> clazz2 = user.getClass();

// 方式3：Class.forName("全类名")（最灵活，框架常用）
Class<?> clazz3 = Class.forName("com.example.User");

2. 操作构造方法：动态创建对象

Class<?> clazz = Class.forName("com.example.User");

// 获取无参构造方法并创建对象
Constructor<?> noArgConstructor = clazz.getDeclaredConstructor();
Object user1 = noArgConstructor.newInstance();

// 获取有参构造方法并创建对象
Constructor<?> argConstructor = clazz.getDeclaredConstructor(String.class, int.class);
Object user2 = argConstructor.newInstance("张三", 25);

3. 操作字段：动态获取/设置属性

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public字段并赋值
Field nameField = clazz.getField("name");
nameField.set(user, "张三");

// 获取private字段并赋值（需打破封装）
Field ageField = clazz.getDeclaredField("age");
ageField.setAccessible(true); // 关键：打破private访问限制
ageField.set(user, 25);

4. 操作方法：动态调用方法

Class<?> clazz = Class.forName("com.example.User");
Object user = clazz.getDeclaredConstructor().newInstance();

// 获取public方法并调用
Method setNameMethod = clazz.getMethod("setName", String.class);
setNameMethod.invoke(user, "张三");

// 获取private方法并调用（需打破封装）
Method getAgeMethod = clazz.getDeclaredMethod("getAge");
getAgeMethod.setAccessible(true);
int age = (int) getAgeMethod.invoke(user);

实际应用场景

Java生态里的核心框架几乎都用到了反射，比如：

1. Spring框架的IOC/DI

Spring的IOC容器就是通过反射创建对象并注入依赖的：

在XML里写 <bean id="user" class="com.example.User"/>➡️Spring读取XML，拿到全类名 com.example.User➡️Spring通过 Class.forName() 获取Class对象，动态创建Bean对象➡️如果Bean有依赖（比如 userService 依赖 userDao），Spring再通过反射注入依赖。

2. JDBC加载数据库驱动

Class.forName("com.mysql.cj.jdbc.Driver")，底层就是反射：首先加载驱动类到JVM，接下来驱动类的静态代码块会自动执行，把驱动注册到 DriverManager 里。

3. 注解处理

比如JUnit的 @Test 注解：JUnit启动后，通过反射扫描所有类，找到带 @Test 注解的方法，再通过反射动态调用这些方法执行测试。

反射的优缺点

优点

灵活性高：运行期才确定要操作的类，不需要在编译期写死；
动态性强：适合开发通用框架（如Spring、MyBatis），框架不需要知道用户会写什么类，通过反射就能动态适配。

缺点

性能低：反射比直接调用方法慢10-100倍（因为需要动态解析类信息），所以高频调用的场景（比如循环里）尽量不用反射；
破坏封装性：可以通过 setAccessible(true) 访问private字段/方法，破坏了Java的封装原则；
安全性问题：反射可以执行任意代码，可能被恶意利用。

Spring Boot的多环境配置

Mon, 26 Jan 2026 15:27:48 +0000

在开发Spring Boot项目中，如果我们想把自己的项目开源到Github仓库，application.yml中的某些配置比如MySQL、Redis的账户密码，还有的就是现在引入AI之后的一些密钥，可能都不太愿意推送到仓库去。

这个时候，可以通过配置多环境来解决，给本地一个专有的配置文件，然后将其添加到.gitignore文件中，这样就有效解决了这个问题。

下面介绍一下 Spring Boot的多环境配置方法：

Spring Boot 支持的多环境配置文件，命名规则为 application-{profile}.yml（profile 是环境标识，如local/dev/test/prod）。

操作步骤

application.yml（公共配置）

spring:
  application:
    name: xxx
  profiles:
    active: local  # 激活local环境

# springdoc-openapi（所有环境都用这个扫描包，通用）
springdoc:
  group-configs:
    - group: 'default'
      packages-to-scan: com.xx.xx.controller

# knife4j（所有环境都开启，中文界面，通用）
knife4j:
  enable: true
  setting:
    language: zh_cn

application-local.yml（本地开发专属配置）

# 本地专属：端口、上下文路径
server:
  port: xxxx
  servlet:
    context-path: /api

# 本地专属的其他配置（比如数据库、日志、Redis等）
# spring:
#   datasource:
#     url: jdbc:mysql://localhost:3306/xx?useSSL=false&serverTimezone=UTC
#     username: xx
#     password: xx
#     driver-class-name: com.mysql.cj.jdbc.Driver
# logging:
#   level:
#     com.xx.xx: debug  # 本地开发开启debug日志
# redis:
#   host: localhost
#   port: xxxx

通过在 application.yml 中配置 spring.profiles.active 激活指定环境，最后的加载顺序就是：

先加载公共配置 application.yml；
再加载激活的环境配置 application-local.yml；

这样的话，环境配置中的同名配置项会覆盖公共配置，不同配置项自动合并，实现 “公共 + 专属” 并存。

JDK版本的区别

Mon, 26 Jan 2026 15:05:04 +0000

在IDEA中新建Spring Boot项目时，需要选择JDK版本，这里小记一下：

Oracle OpenJDK

Oracle 官方维护的开源免费JDK，Java标准实现。

Amazon Corretto

亚马逊基于 OpenJDK 定制的免费、长期支持JDK。

JetBrains Runtime

JetBrains（IDEA/PyCharm 等 IDE 厂商）专为 IDE 自身运行定制的 JDK。

什么是RPC框架

Mon, 19 Jan 2026 17:43:23 +0000

RPC（Remote Procdure Call）远程过程调用是一种用于实现在分布式系统中进行跨网络通信的技术，也是一种计算机通信协议。

RPC框架是基于RPC协议实现的。

RPC允许一个程序（服务消费者）像调用自己程序的方法一样，调用另一个程序（服务提供者）的接口，无需关心数据的传输处理、数据编解码和底层网络通信的细节。

这样一种功能的实现都是由RPC框架来完成的，这就使得开发者能够更轻松地调用远程服务，快速开发分布式系统。

RPC框架通常采用的是高效地网络通信协议（主流为性能远超HTTP的TCP协议）和高效轻量的序列化/反序列化机制；

RPC框架提供的负载均衡、服务发现和容错机制（超时重试、熔断降级、限流等）可以提高系统的可靠性、可用性以及稳定性。

除此之外，开发者还可以自定义负载均衡器和序列化协议，动态地扩展RPC的功能。

什么是Spring-Bean

Mon, 19 Jan 2026 15:50:02 +0000

任何通过Spring 容器实例化、组装和管理的Java对象都能称之为Spring Bean。

Bean可以看成是Spring应用中的一个普通Java对象，这个对象的创建、属性赋值、初始化、销毁等完整的生命周期是由Spring IOC容器来统一管理的，并非程序员手动控制。

Spring Bean的生命周期分为实例化、依赖注入、初始化以及销毁这4个固定不可逆的阶段。

当Spring 容器启动时，会根据配置文件或者注解，先实例化Bean；

之后，Spring 容器再通过注解（@Autowired）或者setter方法将Bean的依赖属性注入进来；

依赖注入完成后，如果Bean标注了@PostConstruct注解、实现了InitializingBean接口或者配置了init-method，Spring就会调用相应的初始化方法，完成Bean的初始化操作。

初始化完成后，Bean就进入到了就绪状态，可以被程序获取和使用了。

如果Bean标注了@PreDestroy注解、实现了DisposableBean接口或者配置了destroy-method，Spring会在容器关闭时调用对应的销毁方法，完成Bean的资源释放。

什么是Spring-IOC

Sun, 18 Jan 2026 18:12:06 +0000

Spring IOC（Inversion of Control）控制反转是将对象的创建权和对象之间依赖关系的维护权，从程序员的业务代码中转移到由Spring IOC容器中，程序员就不再手动控制了。

需要说明的是，Spring IOC是一种设计思想，不是一个具体的技术，Spring IOC 的具体落地实现是通过依赖注入（Dependency Injection）完成的。

依赖注入的方法有构造器注入、setter注入和接口注入三种。

那控制反转它控制的是什么呢？

其实就是控制的是对象的创建过程，Spring IOC容器会根据配置文件来创建对象。

那反转的是什么呢？

反转的是创建对象并且为这个要创建的对象注入它所依赖的对象这个动作的主动权。

传统开发过程是由程序员主动new一个对象，手动注入依赖，Spring IOC是将这个动作交给容器来自动完成，这样主动权就发生了反转。

举个🌰说明一下：

比如对象A依赖对象B，那在创建对象A的代码里，我们就需要写好应该如何创建对象B，只有这样才能创建一个完整的对象A。

但是，反转之后，这个动作就会由Spring IOC容器去触发，容器在创建对象A的时候，发现对象A它依赖对象B，根据配置文件，容器就会创建对象B，然后将对象B注入到对象A中。

这里要注意一下，例子中的是注入一个对象，其实还可以注入配置文件中的一个值、集合等等。

说说Java中的反射机制

Sun, 18 Jan 2026 17:36:55 +0000

反射机制是让程序在运行的时候能够动态地获取类的方法、字段、构造函数这些结构信息，还能对其直接进行操作，这样，程序在编译时不需要知道具体的类型，等到运行时再决定要调用哪个类和方法。

反射机制主要有3大核心流程：

获取Class对象➡️获取成员信息➡️操作目标对象。

获取Class对象的方式：

1.全限定类名获取

`1`	`Class<?> cla = Class.forName("xxx.xxx.MyClass");`

2.字面量获取

`1`	`Class<?> cla = MyClass.class;`

3.对象实例获取

`1`	`Class<?> cla = obj.getClass();`

获取成员信息

主要是从Class对象中获取字段Field、方法Method以及构造函数Constructor

操作目标对象

主要是创建实例、读写字段和调用方法。

Java中HashMap的默认负载因子为什么设置为0.75

Sun, 18 Jan 2026 17:11:19 +0000

0.75这个数字其实是一个时间和空间之间的平衡点。

负载因子决定了什么时候会触发扩容。

HashMap的扩容阈值=容量✖️负载因子。

举个栗子：

比如容量是16，负载因子是0.75，这样存到第12个元素的时候就会触发扩容；

那如果负载因子改成0.5，这样存到第8个元素就会触发扩容；

如果负载因子改成1，那这样只有存满16个元素才会触发扩容。

所以，

负载因子如果设置的太低，桶里的元素就会越稀疏，这样虽然查找速度会更快，但是会造成内存空间的浪费；

负载因子如果设置的太高的话，桶里的元素就会越密集，虽然节省空间，但是冲突也会变多，这样查找就会变慢。

0.75是一个折中的值，既不会让数组太过空旷，也不会让链表太长，在大多数场景下都能保持不错的性能。

说说Java中的JIT

Sat, 17 Jan 2026 18:18:18 +0000

JIT（Just In Time）即时编译，是一种在程序运行时将字节码转换为机器码的技术。

JIT在Java程序运行的时候，如果发现了频繁执行的代码段，我们称之为热点代码，就会将这段热点代码编译成机器码，从而减少解释执行的开销。

JIT有CLient Compiler和Server Compiler两种编译类型，

其中，Client Compiler适用于客户端应用程序，主要用于快速启动的轻量级优化；

Server Compiler适用于服务端应用程序，主要用于长时间运行的重度优化。

说说Java中的Logging-Write-Barrier

Sat, 17 Jan 2026 18:17:05 +0000

Write Barrier可以理解为JVM在对象引用赋值操作中插入的一段AOP代码，通过这段代码，在应用程序运行期间，垃圾收集器可以感知到对象引用关系的变化，从而维护记忆集（RSet）、卡表（Card Table）等必要的数据结构，避免全堆扫描。

Write Barrier按时机分，有Pre-Write Barrier和Post-Write Barrier两种类型。

Pre-Write Barrier在对象引用改变前触发，用于记录引用变更前的状态；

Post-Write Barrier和Pre-Write Barrier相反，是在对象引用改变后触发，用于记录引用变更后的状态。

Logging是一种策略，在G1收集器中，Post和Pre Write Barrier都采用了Logging机制来实现，也就是先记录日志，后异步处理。

那为什么要用Logging这样一种策略呢？

主要是如果每次引用修改都直接去更新RSet这种复杂的全局数据结构，这样会严重拖慢应用线程，并可能会导致多线程下的伪共享问题。

如果采用Logging机制，将对象的引用变更记录丢给应用线程负责，让后台线程负责复杂的处理，使对象的引用变更记录和处理解耦，从而保证在GC正确的前提下，最大程度地减少对应用程序吞吐量的影响。

Java的CMS垃圾回收流程

Fri, 16 Jan 2026 17:20:13 +0000

1.初始标记（initial mark）

CMS会标记所有根对象直接可达的对象。

2.并发标记（Concurrent marking）

并发标记阶段，垃圾收集器和应用程序并发执行，从根对象直接可达的对象开始进行tracing，递归的扫描所有可达对象。

3.并发预清理（Concurrent precleaning）

并发预清理阶段会先分担一些重新标记阶段的工作，扫描卡表脏的区域以及新晋升到老年代的对象。

4.可中断的预清理阶段（AbortablePreclean）

可中断的预清理阶段也是先分担一些重新标记阶段的工作，和并发预清理阶段不同的是这个阶段可以中断。

5.重新标记（remark）

因为前几个并发阶段会导致引用关系发生变化，所有需要重新遍历一遍新生代对象、GC Roots和卡表等，从而对标记进行修正，需要花较长的时间来进行重新扫描。

6.并发清理（Concurrent Sweeping）

并发清理阶段，标记为不可达的对象会被清理。

7.并发重置（Concurrent Reset）

重置CMS内部的状态。

Java中的继承机制

Fri, 16 Jan 2026 16:29:52 +0000

在Java中，允许子类复用父类的字段和方法，用extends关键字建立继承关系。

Java只支持单继承，也就是一个类最多只能有一个直接父类。

子类可以继承父类的public和protected成员；对于父类的private成员，子类只能通过父类提供的public/protected方法来间接地访问。

子类的构造方法执行之前必须先调用父类的构造方法。

如果父类存在无参数的构造方法，则编译器会自动加上super();

如果父类不存在无参数的构造方法，只存在带参数的构造方法，则子类必须显示地调用super(参数)，因为编译器默认插入的是无参的super()方法，会导致编译报错。

继承在带来代码复用的同时也带来了紧耦合问题。

子类在重写父类的方法时，只能放大或者保持方法的访问权限，不能缩小访问权限。

也就是说，

父类如果是public方法，则子类只能是public；

父类如果是protected方法，则子类可以是protected或者public。

因为在父类引用指向子类对象时，调用方是期望能访问到这个方法的，如果子类缩小了这个权限，就会导致调用方无法访问。

在Linux系统中如何使用ssh进行远程登录

Wed, 14 Jan 2026 17:07:17 +0000

1.首先需要确保远程服务器和本地主机都安装了OpenSSH软件；

2.如果采用用户名为“Javaer_12”连接到远程主机"192.168.1.114"，可以输入以下指令：

`1`	`ssh Javaer_12@192.168.1.114`

3.第一次连接的时候可能会提示你确认主机的真实性，输入yes即可，再输入远程服务区的密码即可登录。

⚠️ 注意：只能输完整的 yes，输 y 无效

使用输入密码的方式进行登录，时间长了会感觉比较麻烦，这时可以考虑通过密钥验证的方式进行登录。

通过密钥进行登录的大概就两步：

先在本地生成ssh密钥对：

`1`	`ssh-keygen -t rsa`

再将公钥复制到远程服务器上：

`1`	`ssh-copy-id Javaer_12@192.168.1.114`

这样有时还是会感觉有点麻烦，可以使用.ssh/config文件进行配置：

1
2
3

Host my_server_name
	HostName 192.168.1.114
	User Javaer_12

接下来就可以通过输入ssh my_server_name来进行登录了。

什么情况下会触发Java的Full-GC

Wed, 14 Jan 2026 16:29:41 +0000

整理了以下5种可能会触发Java的Full GC的情况：

1.当老年代的空间不足并且无法通过老年代的垃圾回收以释放足够多的空间时，会触发Full GC来回收老年代中的对象。

2.在Java 8以前，如果永久代的空间不足，会直接触发 Full GC。在Java 8及以后，永久代被元空间取代，由于元空间手动设置了最大阈值，当内存耗尽时也可能会触发Full GC。

3.当显示地调用System.gc()方法时，JVM可能并不能保证立即执行Full GC，但是有可能会触发。

4.当新生代的to区放不下从eden区和from区拷贝过来的对象或者新生代的大对象或者长期存活的对象晋升到老年代时，如果老年代没有足够的空间来容纳这些对象，这个时候也会触发Full GC。

5.在要进行新生代GC的时候，如果根据之前的统计数据发现新生代的平均晋升大小比现在的老年代剩余空间还要大，也会触发 Full GC。

为了减少Full GC 的触发，可以考虑以下策略：

调整堆内存的大小，从而减少老年代空间不足的情况
增大新生代的大小，从而减少对象晋升到老年代的频率
设置合理的元空间大小，从而避免元空间过小导致的频繁Full GC

请解释一下Java中的强引用、弱引用、软引用和虚引用

Tue, 13 Jan 2026 16:57:03 +0000

强引用（Strong Reference）

这是最常见的引用类型。

只要一个对象有强引用指向它，即便是系统内存紧张，垃圾回收器也不会回收该对象。

软引用（Soft Reference）

软引用是用来描述一些还有用但是并非必需的对象，通常用于实现缓存机制，允许程序在不影响性能的情况下利用多余的内存。

当系统内存不足时，垃圾回收器会对软引用指向的对象进行回收，避免内存溢出。

弱引用（Weak Reference）

弱引用是比软引用更弱的一种引用类型，常用于防止内存泄露，允许缓存的键值对在不再使用的时候自动清除。

和软引用在系统内存充足的情况下不会被回收不同的是，弱引用只要被垃圾回收器发现只有它指向某个对象时，不管系统内存是否充足，这个对象都会被回收。

虚引用（Phanton Reference）

虚引用是最弱的一种引用类型，主要就是用来跟踪对象的垃圾回收状态。

如果一个对象只有虚引用，那么这个对象随时会被垃圾回收器回收。

虚引用必须和引用队列（ReferenceQueue）配合使用，否则虚引用就毫无意义。

JVM的内存区域是怎么划分的

Sun, 11 Jan 2026 16:36:51 +0000

JVM的内存区域指的是JVM的运行时数据区。

主要分为方法区、堆、虚拟机栈、本地方法栈和程序计数器五个主要区域。

1.方法区（Method Area）

线程共享区域，存着类的结构信息、常量、静态变量。

2.堆（Heap）

最大的共享区，专门放对象和数组。

3.虚拟机栈（JVM Stack）

线程私有，存着局部变量、操作数栈、动态链接、方法出口信息、基本类型变量、对象引用。

4.本地方法栈（Native Method Stack）

线程私有，用来分配内存给非Java方法。

类似于虚拟机栈，专为JNI调用本地代码服务。

5.程序计数器（Program Counter Register）

每个线程都有一个独立的程序计数器，线程私有。

保存当前线程执行的Java 方法字节码指令的地方或者行号。

说说Java中的常量池

Sat, 10 Jan 2026 17:02:58 +0000

Java中的常量池是一块用于存储运行时常量或者符号的区域。

主要有字符串常量池和运行时常量池。

字符串常量池用于存储字符串字面量，可以通过String类中的intern()方法复用常量池中的字符串对象，若不存在则将当前字符串对象入池。

Java6中的字符串常量池位于方法区中的永久代中，Java7及以后位于堆内存中的特殊区域。

在Java中，字符串的创建方式有两种，一种是直接使用字面量，另一种是使用new关键字。

运行时常量池存储的是每个类或者接口的Class文件编译时生成的常量信息。

需要说明的是，按照JVM的定义来说，字符串常量池逻辑上还是属于运行时常量池，只是因为字符串的高频使用，被单独抽离出来做了优化设计。

整理Java中Object类的方法和作用

Sat, 10 Jan 2026 15:47:23 +0000

public boolean equals(Object obj)	用来比较两个对象是不是相等，默认比较的是内存地址。
public int hashCode()	返回当前对象的哈希值
public String toString()	返回对象的字符串形式
public final Class getClass()	返回对象运行时的类信息，反射的时候经常用到
public void notify()	唤醒一个正在等待当前对象的线程。必须在synchronized代码块中配合wait()一起使用
public void notifyAll()	唤醒所有在这个对象上等待的线程
public void wait()	当前线程挂起，等待别的线程来notify它，只能在同步块/同步方法中使用
public void wait(long timeout)	在wait方法的基础上加了个超时控制，过了时间就自己醒来
public void wait(long timeout,int nanos)	在wait()方法的基础上加了个更精细的超时控制，支持纳秒级的等待
protected Object clone()	拷贝当前对象，默认是浅拷贝
protected void finalize()	对象被垃圾回收之前会自动调用这个方法

Java中怎么判断对象是否是垃圾

Fri, 09 Jan 2026 16:00:00 +0000

主要是采用引用计数法和可达性分析算法两种方式来实现。

引用计数法（Reference Counting）

每个对象维护一个引用计数器，当引用计数增加时，计数器加1，减少时，计数器减1。

当引用计数器为0时，说明该对象不再被引用，此时可以被回收。

这种方法实现起来比较简单而且实时性好，但是无法处理循环引用的问题。

可达性分析算法（Reachability Analysis）

这是Java中的垃圾回收主要采用的方法。

通过一组成为“GC Roots”的对象出发，遍历所有可达的对象，对于一切无法通过GC Roots到达的对象，均可视为垃圾。

这种方法可以解决循环引用的问题，但是需要消耗一定的资源进行标记。

解释一下NIO、BIO、AIO

Fri, 09 Jan 2026 14:45:00 +0000

NIO（Non-blocking I/O），非阻塞I/O模式，调用方在发起I/O操作后即使操作未完成，也能立即返回。

结合I/O多路复用技术，可以使一个线程同时管理多个连接。

适用于连接数多、高并发和高性能要求的场景。

BIO（Blocking I/O），传统的阻塞式I/O模式，调用方在发起I/O操作时会被阻塞，直到操作完成后才会继续执行。

适用于连接数较少，逻辑简单的场景。

AIO（Asynchronous I/O）异步I/O模式，调用方在发起I/O请求后，不需要轮询或者等待I/O操作完成，可以继续执行其他任务，操作系统或者底层库会在I/O操作完成后，通过回调或者事件通知的方式告知调用方。

适用于对响应时间要求较高的应用场景。

PO、VO、BO、DTO、DAO、POJO有什么区别

Thu, 08 Jan 2026 17:58:10 +0000

PO（Persistent Object）持久化对象，主要用于和数据库交互，是数据库数据在内存中的镜像。

VO（View Object）视图对象，和前端展示强相关，按需组装前端需要的字段。

BO（Business Object）业务对象，封装业务逻辑，包含业务处理方法，是业务层专用，业务层只操作BO，不直接碰PO/DTO。

DTO（Data Transfer Object）数据传输对象，屏蔽底层 PO 结构，可细分 ReqDTO（请求）和 ResDTO（响应），用于跨层或者跨服务传输数据。

DAO（Data Access Object）数据访问对象，负责和数据库打交道，隔离业务逻辑和数据操作，依赖PO，通过操作PO完成与数据库的交互。

POJO（Plain Ordinary Java Object）简单Java对象，最基础的Java类。

PO/VO/BO/DTO 本质上都是 POJO。

常见的调用链路：

前端请求 → Controller接收【ReqDTO】→ Service将ReqDTO转为【BO】→ BO调用【DAO】→ DAO操作【PO】与数据库交互 → Service将BO/PO转为【ResDTO/VO】→ Controller返回给前端

Java中有哪些垃圾回收算法

Thu, 08 Jan 2026 16:54:37 +0000

Java中的垃圾回收算法主要有3种，分别是标记-清除算法、复制算法、标记-整理算法。

1.标记-清除算法

这种算法的逻辑其实很简单，就是先遍历一遍，把有用的东西都打个勾✅（标记），然后把那些没打勾的垃圾直接扔掉（清除）。

不过，这种算法存在一个缺点，就是会留下内存碎片。

2.复制算法

复制算法可以很好地解决内存碎片问题，这种算法是把内存一分为二，平时只用一半。

回收的时候，会把活着的对象全部复制到另一半去，然后把原来的那一半直接清空。

这种算法的优点是快，可以保证没有碎片，但是需轮流着一半的空间不能用，太浪费空间了。

3.标记-整理算法

标记-整理算法是老年代常用的算法。

对老年代的对象，因为存活的时间长，如果采用复制算法，需要复制一大堆，速度太慢；

但是，标记-清除又会产生碎片。

所以，标记-整理算法是先进行标记，然后把所有活着的对象往一端推，再把剩下的空间全部清空。

通过这种方式，既不会产生碎片，也不会浪费掉一半的空间，不过，把所有活着的对象往一端推这个整理的动作会比较耗时。

JVM由哪些部分组成

Wed, 07 Jan 2026 16:43:37 +0000

JVM主要由类加载子系统（ClassLoader）、运行时数据区（Runtime Data Area）、执行引擎（Execution Engine）以及本地方法接口（Native Interface）4个部分组成。

JVM就像一个虚拟的“电脑”，能让Java程序在不同的操作系统上跑起来。

核心工作流程是：

编写好的Java代码在编译成class文件之后，

类加载器首先负责把class文件从磁盘或者网络中拉进来，放入到内存中；

运行时数据区主要用于存放代码和变量；

执行引擎像个翻译官，把Java的字节码转成机器码；

当需要调用C++之类的外部代码时，就通过本地方法接口来帮忙桥接。

Spring-Boot支持哪些嵌入Web容器

Wed, 07 Jan 2026 16:27:41 +0000

Spring Boot支持以下4种嵌入Web容器：

1.Tomcat

Spring Boot默认的嵌入式Web容器，Spring Boot会自动地将Tomcat内嵌到应用程序中，是一种广泛使用的轻量级、广泛使用的Servlet容器。

2.Jetty

Jetty比Tomcat更轻量，是一个高效的Web服务器和Servlet容器，通常用于嵌入式系统或对资源占用较为敏感的环境。

3.undertow

undertow支持异步IO和HTTP/2，是一个轻量级的高性能Web服务器和Servlet容器，适用于处理高并发的HTTP请求。

4.Netty

Netty是一个非阻塞的异步事件驱动框架，是Spring WebFlux的默认嵌入式容器，仅适用于响应式编程模型，适合高并发的响应式应用。

你知道Spring-Boot配置文件的加载优先级吗

Wed, 07 Jan 2026 15:59:34 +0000

优先级如下：

命令行参数> JAR包外的application-{profile}.properties> JAR 包外的application.properties>JAR包内的application-{profile}.properties>JAR包内的application.properties。

需要注意的是：

当application.properties和application.yml同时存在时，如果是相同的参数，最终生效的是application.properties中的配置。

常用的JVM配置参数

Mon, 05 Jan 2026 15:48:48 +0000

-Xms	初始化堆内存大小
-Xmx	最大堆内存大小
-Xss	设置每个线程的栈大小
-XX:MetaspaceSize	初始化元空间大小
-XX:MaxMetaspaceSize	最大元空间大小
-XX:+HeapDumpOnOutOfMemoryError	当发生OOM时，生成堆转储
-XX:+PrintGCDetails	打印详细的垃圾回收日志
-XX:+UseG1GC	启用G1垃圾收集器
-XX:+UseConcMarkSweepGC	启用CMS垃圾收集器
-XX:+UseZGC	启用ZGC低延迟垃圾收集器

Spring-Bean一共有几种作用域

Mon, 05 Jan 2026 14:53:26 +0000

六种。

singleton	默认是单例，一个 Spring IOC容器的内部只有一个Bean实例
prototype	原型，每次获取都会新建实例
request	每个请求都会新建一个属于自己的Bean实例
session	一个http session中有一个Bean的实例
application	整个ServletContext生命周期里，只有一个Bean实例
websocket	一个WebSocket生命周期内只有一个Bean实例

request、session、application、websocket这四种作用域都是只存在于Spring Web应用中的。

整理一些可用来分析JVM性能的工具

Sun, 04 Jan 2026 16:32:39 +0000

jmap	一种用于生成堆转储的命令行工具，可以用于分析JVM的内存使用情况
jstack	一种用于生成线程转储的命令行工具，可以用于分析线程的状态
jstat	一种用于监控JVM统计信息的命令行工具，可提供实时的性能数据
MAT	一种用于分析堆转储文件的工具，可以帮助识别内存泄漏和优化内存使用
jconsole	可以监控JVM的内存使用，垃圾回收、线程、类加载等信息
VisualVM	可实时显示JVM的内存使用、垃圾回收类加载等信息
Arthas	一个强大的Java诊断工具，提供实时监控和分析的功能

说说Spring-Boot-Actuator

Sun, 04 Jan 2026 14:33:48 +0000

Spring Boot Actuator是一个具有监控和管理功能的工具。

通过Actuator可以监控应用的健康状况、查看指标、跟踪请求、管理环境参数等等。

Actuator的优势：

1.开箱即用，可以很容易地与外部监控系统集成。

2.提供了大量预定义的端点，可以用于展示和操作应用的内部状态，并且还支持自定义端点，扩展现有的端点功能。

3.提供了关于应用、系统、JVM、内存、线程等丰富的信息。

4.支持端点的安全访问控制，可以限制哪些端点可以公开访问。

Java对象是怎么在虚拟机中存储的

Sat, 03 Jan 2026 16:19:53 +0000

Java对象在虚拟机中主要由对象头、对象实例和对齐填充三部分组成。

1.对象头中包含了对象的元信息和运行时数据。

对象头主要由Mark Word、类型指针和数组长度三部分组成。

其中，数组长度只有数组才有；

Mark Word主要用于存储运行时数据，会根据对象的状态动态变化；

类型指针指向对象对应的类的元数据，用于确定该对象的类型。

2.对象实例存储的是对象的实际数据，也就是类的字段。

3.为了满足内存一般情况下的8字节对齐要求，JVM可能会在对象的末尾添加填充字节。

至于存储位置，大多数的对象分配在堆中，堆也是JVM管理的内存中最大的一块区域。

Spring是怎么解决循环依赖的

Sat, 03 Jan 2026 15:15:01 +0000

Spring是通过三级缓存机制来解决循环依赖的。

我们可以把这三级缓存想象成3个不同等级的“货架”：

其中，一级缓存存放的是成品货架，这里面都是完全初始化好，并且可以直接使用的Bean。

二级缓存存放的是半成品货架，这里面都是已经实例化好的，但是呢，还没有填充属性的Bean。

三级缓存存放的是工厂货架，这里放的就不是Bean了，而是一个可以生产Bean的工厂。

我们来理一下三级缓存解决循环依赖的流程：

假设A和B是相互依赖的，

首先，Spring先把A实例化出来，此时A还只是一个空壳，紧接着把一个可以获取A的工厂放到三级缓存里。

然后，A开始填充属性，这时发现需要B，所以就跑去创建B。

这时，B也实例化出来了，也开始填充属性，发现需要A。

然后，B就去一级缓存中寻找A，但是呢，没找到；所以又去二级缓存中寻找，也没找到；再跑去三级缓存中寻找，这下找到了。

这时，B就调用三级缓存中的工厂，拿到了A的引用。

为了保证是单例，只生产一次，B就把拿到的A放到二级缓存中，并把三级缓存中的工厂删掉。

B拿到了A后，B就创建完成了，入驻一级缓存。

A拿到B之后，A也可以创建完成，也可以入驻一级缓存。

说说Java程序的执行流程

Fri, 02 Jan 2026 16:32:54 +0000

Java程序的执行流程：

1.编写.java源代码文件。

2.使用javac编译器生成.class字节码文件。

3.通过java命令启动JVM，并指定主类。

4.JVM类加载器按需加载主类及运行所需的其他.class文件。

5.JVM定位到主类的main方法，开始执行其逻辑，作为程序的入口。

6.执行过程中，JVM通过解释执行和JIT即时编译，将字节码转换为机器码并执行。

7.运行期间，JVM对内存进行管理，回收不再使用的对象。

8.如果没有非守护线程运行，则触发JVM退出流程。

9.JVM销毁内部组件，释放资源，最终JVM进程退出。

JVM方法区会出现内存溢出吗

Fri, 02 Jan 2026 15:19:31 +0000

在Java8以前，方法区被实现在永久代中，永久代是一块固定大小地内存区域，这块区域不能进行动态地扩展。所以，如果加载的类过多或者常量池的数据过多，超出了永久代的限制，就会报永久代内存溢出的错误。

在Java 8及之后，方法区被实现在元空间中，不再使用堆内存，转向使用本地内存，元空间可以通过参数设置最大大小，但也会受物理内存的限制。

所以，如果加载的类过多或者大量动态生成类还是会报元空间内存溢出的错误。

Spring-Boot-2.x和1.x版本相比有哪些区别与改进

Fri, 02 Jan 2026 15:02:23 +0000

昨天说了Spring Boot 3.x和2.x版本相比有哪些区别与改进？，今天来看看Spring Boot 2.x和1.x版本相比有哪些区别与改进？

1.Spring Boot 1.x基于Spring Framework 4.x，不支持响应式编程；Spring Boot 2.x基于Spring Boot 5，引入了对响应式编程的支持。

2.Spring Boot 2.x对Tomcat、Jetty这些嵌入式Web容器的默认版本进行了升级，带来了对新HTTP标准的支持。

3.Spring Boot 2.x对底层组件和框架本身做了大量的性能优化，使得应用启动时间更短，运行性能更高，更加适合云原生应用和大规模的微服务架构。

4.Spring Boot 1.x中，Actuator端点是默认全部开启的，存在安全上的隐患，Spring Boot 2.x对Actuator进行了全面改进，在默认情况下，大多数端点是关闭的，开发者可以通过配置显示地启动需要的端点。

Java是怎么实现跨平台的

Thu, 01 Jan 2026 17:02:43 +0000

跨平台指的是在不同的硬件或者操作系统上，Java代码在不需要针对不同的平台做对应的修改的前提下，都可以正常运行。

要实现这样一种一次编写到处运行的特性，主要靠的是JVM，即Java虚拟机。

和其他编程语言在编译后直接生成特定于某一操作系统的二进制01机器代码不同，Java程序在编译之后生成的是.class格式的字节码。

JVM为了屏蔽不同硬件或操作系统的底层细节，针对不同的平台做了对应的开发，可以实现将字节码翻译成特定平台上的机器代码并成功执行，这就使得同一份Java字节码可以在任意的支持JVM的平台上正常运行。

Spring-Boot-3.x和2.x版本相比有哪些区别与改进

Thu, 01 Jan 2026 16:05:33 +0000

1.Spring Boot 2.x基于Java EE，而Spring Boot 3.x迁移到了Jakartaa EE，一些核心的包名也从javax.*变更为jakarta.*了。

2.Spring Boot 2.x支持JDK8、11和17版本，而Spring Boot 3.x要求JDK版本最低为17。

3.Spring Boot 2.x 没有原生编译的内置支持，Spring Boot3.x则提供了对GraalVM Native Image的开箱即用支持，可以将Spring应用编译成本地的可执行文件。

4.Spring Boot 2.x仅支持基本的监控和追踪，Spring Boot 3.x引入了更完善的分布式追踪、日志关联和性能指标收集，支持OpenTelemetry标准，开发者可以借助Observability更好地监控和分析应用的运行状况。

5.Spring Boot 2.x支持Spring Security 5，在安全性上存在一定的局限性；Spring Boot 3.x增强了对Spring Security 6的支持，强化了身份认证、授权和安全配置的能力。

6.Spring Boot 2.x的依赖库和自动配置很强大，但是存在一些历史遗留的依赖和配置；Spring Boot 3.x对内部依赖进行了一些模块化的调整，对一些不再使用或者过时的库进行了清理。

什么时候@Async会失效

Thu, 01 Jan 2026 14:12:06 +0000

有多种原因可造成@Async失效：

1.@Async依赖于Spring AOP，如果是内部调用的话则会绕过代理对象，直接调用原始方法。

2.Spring AOP默认只会对public方法生效，对于非public方法则不会被代理，所以此时@Async是失效的。

3.如果Spring Boot的主类或者配置类上没有添加@EnableAsync注解，也就是没有显示启用异步功能，则Spring是不会为其生成代理的。

4.@Async依赖于Spring容器管理的Bean，如果是手动new的对象，并没有被Spring管理，则代理机制也是会失效的。

说一说Java中堆和栈的区别

Wed, 31 Dec 2025 16:04:55 +0000

栈主要用于存储局部变量和方法的返回地址、参数等调用信息。

堆主要用于存储对象实例和数组。

JVM的垃圾回收主要是针对堆空间的一个处理，而栈空间是不会被回收的。

在一次方法的调用过程中，调用的时候数据存入栈空间，当方法执行完之后，数据就被弹出释放，

不需要像堆空间一样等待GC进行回收，所以相对而言，栈空间的生命周期会比堆空间更短。

Spring-Boot工程启动以后-怎么将数据库中已有的固定内容打入到Redis缓存中

Wed, 31 Dec 2025 15:49:46 +0000

要想实现在Spring Boot工程启动之后，直接将数据库中已有的固定内容打入到Redis缓存中，首先需要确保实体类已经实现了Serializable接口，并且已经正确配置了RedisTemplate的序列化方式。

可以考虑使用CommanLineRunner或者ApplicationRunner接口，在应用启动完成后执行初始化逻辑；

也可以通过@PostConstruct注解，在Bean创建之后立即执行数据库加载。

在懒加载场景，可以使用@Cacheable注解，在首次调用方法时触发缓存写入，完成预加载。

说一说Linux系统中进程和线程的区别

Tue, 30 Dec 2025 14:50:54 +0000

我们先明确定义：

进程是一个具有独立运行环境的程序实例，操作系统可以通过进程调度来管理CPU的时间分配。

而线程则是进程中一个单独的执行路径，并且一个进程中可以包含多个线程，这些线程共享进程的地址空间和其他资源。

主要区别在于：

1.进程是资源分配的基本单位，线程是CPU调度的基本单位。

2.进程与进程之间是相互独立的，也就是说一个进程的崩溃并不会对其他的进程造成影响。但是，线程之间因为是共享进程的资源的，所以，如果一个线程崩溃了，可能会导致整个进程的崩溃。

3.进程之间的切换开销是大于线程之间的切换的，因为线程是在同一进城内切换，所以会相对轻松点。

4.进程主要应用于Web服务器和数据库管理系统这些场景，线程则主要应用于多线程下载器和并发处理计算任务的场景，比如Java线程池等等。

IDEA2023中新建Spring-Boot2.X版本的工程的方法

Tue, 30 Dec 2025 09:40:44 +0000

因为官方 Spring Initializr 服务（start.spring.io）已停止对 Spring Boot 2.x 系列旧版本的支持，仅保留 3.5.0 及以上新版本的分发，因此无法通过该服务获取 2.x 版本的项目模板。

并且Spring Boot 3.x 强制要求 Java ≥17，只有 2.x 系列支持 Java 8，所以会导致下拉框选不到Java8。

为了解决这个问题，需要将在IDEA 的 Spring Initializr 界面，点击顶部「Server URL」输入框，删除原有地址，输入阿里云的服务地址：

`1`	`https://start.aliyun.com`

之后就能够选择Java 8了。

点击Next之后，也能够选择2.X 系列的Spring Boot版本。

Java面向对象编程和面向过程编程的区别是什么

Fri, 26 Dec 2025 15:11:26 +0000

宏观层面上说：

面向对象是一种以对象为中心，以人类的思维方式来编写代码的编程风格，

而面向过程则是一种以过程或者说函数为中心，以计算机的思维方式来写代码的编程风格。

主要有以下几点区别：

面向对象主要关注的是对象之间的关系和交互，而面向过程主要关注函数的执行步骤和顺序。
面向对象的数据和行为都是封装在对象内部的，而面向过程的数据和函数却是分离的。
面向对象通过它的封装、继承和多态机制具有较高的复用性和可拓展性，而面向过程如果进行扩展可能需要修改已有的代码，复用性往往较低。
从适用场景上来说，面向对象很适合一些复杂系统的开发，而面向过程则只适用于一些简单的顺序性较强的小型项目的开发。

你知道为什么Java不支持多重继承吗

Fri, 26 Dec 2025 14:20:22 +0000

看看这张图，B和C都继承了A，D又继承了B和C。

想象这样一种场景，如果此时需要调用D中的一个定义在A的方法，但是呢，这个方法在B和C中存在不同的实现，这个时候就会出现歧义，从而无法抉择应该调用哪个。

说说Java中的不可变类。

Thu, 25 Dec 2025 17:47:54 +0000

Java中的不可变类指的是在对象完成创建之后无法被修改的类。

最典型的就是String，当然还有所有的基本类型的包装类，比如Integer、Long、Boolean等等。

如果要实现一个不可变类，至少需要同时满足以下5个条件：

为了防止子类继承父类之后添加了一些可变行为，导致不可变性遭到破坏，需要将类声明为final。
为了保证字段只能在构造阶段赋值，并且之后就不能通过外部进行访问或者修改，需要通过private final对字段进行修饰，将变量锁死。
需要通过构造函数一次性初始化所有字段。
可以提供getter方法，但是不能提供setter或者修改状态的方法。
如果类中含有可变对象的引用，需要确保在对象外部无法对这些引用进行修改。

这样一个不可变类，因为不能对它进行修改，所以多线程访问时不需要加锁，天生的线程安全。

又因为它的状态不可变，所以很适合作为缓存的key。

不过，实现这种不可变的代价就是比较费内存。

在Java中参数传递的方式是按值还是按引用

Thu, 25 Dec 2025 16:57:10 +0000

其实啊，在Java中，不管是基本数据类型还是引用数据类型，参数传递的方式都只有按值传递这一种。

对于基本数据类型，也就是（ byte, short, int, double, long, float, boolean, char）这8种，这些都是存储在栈内存中的。作为参数传递时，它们传递的都是值的副本，也就是基本数据类型的数值本身。

对方法中的参数进行操作时，并不会影响原始的变量。

对于引用数据类型，也就是所有的对象和数组，它们存储的是对象在堆内存中的地址，作为参数传递时，传递的是引用的副本。

方法内的修改可以通过引用影响到传入的对象的内容，但是并不会影响对象引用本身的地址。

说说看你认为Java的优势是什么

Thu, 25 Dec 2025 13:12:33 +0000

我认为Java的优势主要有以下几点：

1.因为有JVM这个充当翻译官的角色存在，程序员编写的代码编译成字节码后，不管是在Windows、Linux还是Mac系统上，JVM都可以把它翻译成机器可以读懂的语言，也就是可以实现跨平台，在企业的开发中，便于部署。

2.与C++需要手动的申请以及释放内存不同的是，Java自带了垃圾回收机制（GC），可以实现自动在后台帮程序员打扫内存垃圾，这样的话程序员的精力可以更多的倾向于业务逻辑。

3.Java的生态圈十分的庞大，可以说不管你想做什么功能，基本上你都能找到像Spring全家桶那样现成的并且是成熟的开源库，这样你就不用重复的去造轮子。

4.与面向过程的编程语言不同，Java是一种面向对象的编程语言，具备封装、继承和多态这3个特性。这种面向对象的特性，使得企业在开发和维护那种比较大规模、并且复杂度较高的系统时会相对容易一些。

什么是Java的多态特性

Wed, 24 Dec 2025 18:25:20 +0000

Java的多态指的是父类的引用指向子类的对象，使得在调用同一个方法时，会执行子类自己的实现。

通常来说，多态有3个必要条件。

1.要有继承关系，比如子类继承父类，或者实现关系，比如类实现接口；

2.子类需要重写父类的方法；

3.父类的引用指向子类的对象，换句话说就是把子类类型的对象赋值给父类类型的引用变量，也就是向上转型。

在面试的时候，有些面试官可能会问你多态的作用，多态的作用就两个：

一个是解耦，也就是调用方只依赖父类或者接口，并不会依赖它的具体实现。

另一个是可拓展，就是说可以在完全不修改原有代码的情况下新增一个子类。

多态性的实现方式

在面向对象的编程中，多态性有编译时多态和运行时多态两种实现方式。

编译时多态也称作静态多态，通过方法重载来实现，Java编译器会在编译时根据方法调用时传入的参数类型和数量来决定具体调用哪一个重载方法。

运行时多态也称作动态多态，通过方法重写来实现，当父类的引用调用方法时，在运行时会根据对象的实际类型来决定实际执行的子类重写之后的方法。

其中，

方法重载指的是同一个类的多个方法，它们的名称相同但是参数列表不同。

方法重写指的是子类重写了父类的一个或者多个方法。

Java中的Exception和Error有什么区别

Wed, 24 Dec 2025 16:50:46 +0000

在Java中，Exception和Error两者都是Throwable类的子类。

总体上来说，Exception是指可以被处理的程序异常，属于业务逻辑的范畴，常见的异常有NullPointerException和IOException等等；

而Error则指的是系统级的不可恢复的错误，错误出现以后一般就意味着进程需要终止或者重启，常见的错误有OutOfMemoryError、StackOverflowError等等。

如果细分的话，Exception又可以分为Checked Exception和Unchecked Exception，也就是受检异常和非受检异常。

常见的受检异常有IOException和SQLException，它们都是从Exception继承过来但是并不继承RuntimeException，在编译的时候必须使用try-catch块或者throws声明进行抛出这样的显式处理。

而非受检异常如NullPointerException和IndexOutOfBoundsException都是继承自RuntimeException，它们就不需要进行显式的处理，而是运行的时候才会抛出。

异常处理时需要注意的点：

1.如果什么异常都使用通用Exception，而不是特定的异常，那么其他同事在分析这段代码时就无法一眼看出这段代码实际想要捕获的异常。

所以，尽量不要捕获类似于Exception这样的通用异常，而应该捕获特定的异常。

2.如果我们在捕获异常之后不把异常进行抛出或者使用catch之后再用e.printStackTrace()输出一个标准错误流，这样操作的话也许这只是一个非常简单的bug，但是你仍然不知道是哪里出错了以及出错的原因。

所以，我们可以按需自定义一定的格式，将详细的信息输入到日志系统中，这样的话便于后续进行错误的排查。

3.想象这样一种场景，如果一个方法，这个方法内部调用了其他好几个方法，现在这个最开始的方法的某个参数传入了一个null值，但是，你并没有立刻处理这个情况，而是在这个最开始的方法调用了好几个方法之后才爆出这里其实最开始就有一个空指针。

这样就会造成其实你明明只需要在最开始只抛出一点点信息就能够定位到这个错误所在的地方，但是当最开始的方法调用了其他好几个方法之后你再抛出的可能就是很多的堆栈信息。

因此，最好不要延迟处理异常。

4.try-catch中的代码会影响JVM对代码的优化，因此，使用try-catch块时，不推荐try住一大段代码，而是在必要的代码段使用try-catch，也就是说try-catch的范围应该尽量小。

5.在控制程序的流程这一块，我们一般采取的原则是能用if/else语句来控制的话就不要用异常，直白点说就是不要通过异常来控制程序的流程。

6.在finally中return或者处理返回值往往会发生覆盖try中的return的情况，因此，最好不要在finallly中处理返回值或者return。

Java中的序列化和反序列化是什么

Wed, 24 Dec 2025 15:37:56 +0000

先来说说序列化，序列化是把内存中的对象转变成二进制的数据，通过这种形式才能存储到硬盘或者发送给别人。

再来说说反序列化，由于硬盘和网络都只认识二进制的0和1，不认识Java对象，所以必须进行转换，把二进制的数据变回内存中的对象。

在具体的实现细节上，有怎么做、怎么防、怎么稳这3个问题面试官比较喜欢问。

对于怎么做这个问题，一个类要想实现序列化，就必须实现Serializable接口，这个接口就相当于一个许可证。

至于怎么防，如果有些像密码这种的字段，它不想被保存下来，我们可以通过加上一个transient关键字，这样的话，序列化的时候就会自动跳过这些字段。

对于怎么稳，为了防止你修改了代码之后，在读取旧数据时发生报错，可以加上一个serialVersionUID版本号，这个版本号就相当于一个文件的身份证或者指纹。

这个serialVersionUID可以用来验证序列化的对象和反序列化之后对应的对象的ID两者是否一致。

举个例子说明一下：

比如，如果在没有定义一个serialVersionUID的前提下，接着序列化一个对象，在反序列化之前，在对象中增加了一个成员变量使得对象的类结构发生了改变，这个时候进行反序列化就会失败。原因就是serial VersionUID已经不一致了。

Java on Coder_Studio

Java线程与操作系统线程的生命周期

一篇搞懂：Java包名、Maven artifactId、Spring application.name到底有啥区别？

Java包名 com.codeedgexu.codeedgebackend

作用

小贴士

Maven artifactId codeedge-backend

作用

小贴士

application.yml文件中的codeedge-backend

作用

小贴士

一篇搞懂：LangChain4j结构化输出、TokenStream、SSE、Flux、Reactor到底是什么？

LangChain4j结构化输出

TokenStream + SSE

Flux & Reactor

一张图搞懂

一篇搞懂前后端所有的“器”

前后端对比

【面试真题拆解】Java里面的线程池都有哪些参数？

线程池的7个核心参数

1. corePoolSize：核心线程数

2. maximumPoolSize：最大线程数

3. keepAliveTime：空闲线程存活时间

4. unit：时间单位

5. workQueue：工作队列

6. threadFactory：线程工厂

7. handler：拒绝策略

线程池的执行流程

4种默认拒绝策略

ThreadPoolExecutor 的构造方法

【面试真题拆解】Java的Static关键字到底怎么用？

1. 静态变量

举个例子，用静态变量做全局计数器

2. 静态方法

举个例子，用静态方法做工具类

3. 静态代码块

举个例子，用静态代码块初始化静态配置

小贴士

4. 静态内部类

举个例子，用静态内部类实现线程安全的单例模式

小贴士

【面试真题拆解】你知道ThreadLocal是什么吗

以用户上下文传递举个例子

和加锁保证线程安全的区别

小贴士

ThreadLocal内存泄漏问题

Java中的4种引用强度

ThreadLocalMap的Entry结构

怎么避免内存泄漏

【面试真题拆解】Spring事务机制

事务的四大特性

隔离级别

传播行为

小贴士

23种设计模式，一次性讲明白

记忆口诀

创建型口诀（5种）

结构型口诀（7种）

行为型口诀（11种）

创建型模式

1. 单例模式

类比

适用场景

代码示例

2. 工厂方法模式

类比

适用场景

代码示例

3. 抽象工厂模式

类比

4. 建造者模式

类比

适用场景

代码示例

5. 原型模式

类比

适用场景

结构型模式

1. 适配器模式

Java包名 `com.codeedgexu.codeedgebackend`

Maven artifactId `codeedge-backend`

`application.yml`文件中的`codeedge-backend`

为什么简单数据处理不需要 `throws`？