2401_84390420的博客

原创 redis

AOF 文件体积更大，恢复慢，因为恢复的时候要逐条重放命令。AOF 还有重写机制，用来消除冗余，比如同一个 key 连续 set a、set b、set c、set d，重写之后就只保留一条 set key d，精简文件。消息会被分发到每一个实例的队列，所有实例监听自己的队列，收到消息之后，各自删除本机 Caffeine 里面对应的本地缓存，实现一处修改、全部实例本地缓存失效。HyperLogLog 不存原始数据，基于概率算法估算独立数量，内存极小，支持海量 UV 统计，缺点是结果有微小误差，拿不到明细。

原创 mysql22

客户端请求 → 连接器（身份校验、权限） → 查询缓存（MySQL8.0已经移除） → 解析器：词法分析（识别关键字）、语法分析（校验SQL语法） → 预处理 → 优化器：计算代价，选择最优执行计划 → 执行器：调用存储引擎接口，返回数据。，如果是覆盖索引，可能type=index（扫描全部二级索引），不满足最左前缀，无法快速定位区间。查询时先根据分区键过滤，跳过无关分区，缩小扫描范围，之后再在分区内走索引查询。多个独立索引分别查询，拿到各自符合条件的主键，去重之后，拿着主键回表查询。

原创 MapStruct

一句话收尾： 反射只是加载已有类，只是加载时机延后；动态字节码写错会不停产出新类；MapStruct 提前把转换类全部生成，把风险、类加载时机前置，但它管不住项目其他地方的动态类。

原创 线程池死锁问题

execute：不需要返回结果，任务异常直接打印堆栈日志。submit：需要获取返回结果，异常保存在 Future 对象，调用 get 时才抛出包装异常，不调用 get 异常会静默丢失。死锁场景：同一个线程池，异步任务内部再次提交新任务，并且调用 get 阻塞等待。线程全部被外层任务占住、阻塞不释放，队列内层任务无线程执行，发生线程饥饿死锁。

原创 运维相关666

IO 慢：加索引、优化 SQL、拆分大事务；远程调用加超时、并行、缓存流量大：限流、熔断、降级、缓存（本地缓存 + Redis）、MQ 异步剥离非核心逻辑线程阻塞：阻塞 IO 放到独立弹性线程池隔离，不要占用容器工作线程CPU 高：减少循环、避免大对象、优化序列化、减少不必要计算。

原创 智能体相关

缺点是只能匹配字面关键词，容易召回字面沾边但无关的内容。纯计算场景，同一时间能跑的业务线程上限不一样。是不是就是根据这些指标进行判断，如果说追寻检索速度而且数据量很大不利于语义切割不追求很高的精准度选择文本切割，如果十分的追求精准度还是使用语义切割，但是一般是这两种都有用 RRF 对这两种检索的进行取 topk 的。那其实就说emmbding的时候不支持这么多，但是如果不用emmbding也是说用文本的话那么多的关键词会使我们要找的关键词权重变低比如说你分片那么关键词占比就高就容易定位到。

原创 single-flight解决因请求延迟或者多点导致一个请求发多次并且每次都会执行完整逻辑的场景

核心：用存正在运行任务的，依靠原子判断谁是 owner。Java 手写 SingleFlight 基于 ConcurrentHashMap+CompletableFuture。putIfAbsent 原子抢占 owner；抢到的线程执行业务，try-catch 捕获异常，finally 清理 map 里的 key；没抢到的线程阻塞等待同一个 Future 的结果，复用一次执行的返回，避免重复执行下游逻辑。它是单机方案，多实例无效，等待一定要设置超时，防止线程堆积。

原创 langchain底层原理

搭配 LangGraph 之后，用声明式状态图实现 ReAct Agent，核心特色是统一 State 托管、节点分支编排、基于 checkpointer 的节点级中断和人工介入能力；而手写 while 循环方案没有原生的流程冻结断点，校验失败直接回流错误给大模型，由 AI 自主修复。，它只提供零件，单独用它写 ReAct 你得自己手写 while 循环。恢复的时候直接进入这个下一个节点继续跑，不会重跑已经跑完的节点。，可以从上次中断的节点断点继续跑，不用从头重来。LangChain 本身。

原创 py how claude work项目分析

这里调用工具的思想吧就是为了防止并发问题就是读的时候写的工具改就是这种情况，就是一开始先执行工具也就是ai输出的时候就执行工具但是只会执行为true的工具也就是只读的工具，然后输出完进入下方流程此流程是等待true的工具执行完再执行false的工具，这些true和false是存入字典里面的直接根据工具名称取就行。：API 层是「自动重试」，工具层是「错误回喂让模型自愈」，循环层是「别跑飞、别撑爆」，安全层是「危险动作先拦」，数据层是「太大就削、崩了能续」。修改类工具先压住，不启动。

原创 一些八股和限流措施

就是怕管网络的工人被困在等待数据库这件事上。等待数据库这个耗时间的破活交给临时工干，网络工人专心处理用户请求，服务就不会卡死。需要用弹性线程池：JDBC、Jedis、sleep、读本地磁盘文件，这些都要线程原地傻等外部资源。不需要：WebClient、Lettuce、R2DBC，干完请求直接走开，不靠线程死等，等消息通知再回来处理。开发的时候一般直接用默认的 boundedElastic 弹性线程池，默认最大线程数是 CPU 核心数乘以 10。像 4 核服务器，上限就是 40 个线程。

原创 java知识合集

REQUIRED：内层加入外层，一起回滚。：内层独立，外层回滚不影响内层。你说的完全对。四种事务隔离级别分别是读未提交、读已提交、可重复读、串行化。读未提交可以读到其他事务未提交的数据，如果读到的数据最后回滚了，就产生脏读。读已提交只能读取已经提交的数据，解决了脏读问题，但还会出现不可重复读。不可重复读就是同一个事务内两次读同一行，中间别的事务修改提交，前后读到的数据不一致。举例子：事务里查询订单金额、打印订单标签，中间如果别的线程修改了订单数据，两次读取结果不一样，就会出错。可重复读。

原创 【无标题】

JDK1.8：去掉 Segment，结构和 HashMap 一致：数组 + 链表 + 红黑树。父加载器加载失败，再逐层向下，由自己加载。乐观锁：假设并发冲突很少，不加锁，更新的时候校验数据有没有被修改。并发 resize 时，两个线程同时操作链表，形成环形链表。类加载完成之后，new 对象：在堆的年轻代开辟对象内存。对象初始年龄 0，每一次 Minor GC 存活下来年龄 + 1，在 S0、S1 两个 survivor 区来回拷贝。三层类加载器：启动类加载器、扩展类加载器、应用程序类加载器。

原创 Mybits一级二级缓存

SqlSession 是 MyBatis 的数据库会话，SpringBoot 环境一次 HTTP 请求对应一个 SqlSession，请求结束会话关闭。会话关闭缓存消失，会话内增删改会清空一级缓存，风险很低。二级缓存是 Mapper 命名空间级别，默认关闭，会话提交或关闭后数据才存入，实现跨请求共享；但是粒度粗，修改任意数据清空整个 Mapper 缓存，联表场景容易脏数据，单机有效，生产一般不用，改用 Redis。场景：接口内部调用多个不同方法，多个方法都写了相同查询，不方便传递对象变量，一级缓存生效。

原创 八股666

HyperLogLog 是 Redis 提供的，专门用来统计。它不需要存储原始数据，无论统计几万还是上亿条数据，仅占用约 12KB 内存；存在约 0.81% 的统计误差。只能拿到去重后的估算总数，。

原创 reids的数据结构的应用场景

原创 redis执行get等命令时底层操作

这个底层操作主要要分reids 6和之后的。

原创 JAVA面经

除了 AI 流式输出、WebSocket/SSE 消息推送以外： ✅适合：IO 密集型业务，大量并发数据库访问、大量远程接口调用、实时监控上报等。⚠️重要限制： WebFlux 框架本身非阻塞，如果代码里引入阻塞 API，例如 MyBatis（阻塞 JDBC），执行数据库操作时线程依旧会阻塞，WebFlux 非阻塞优势直接丧失。 想要端到端完整非阻塞，数据库要使用 R2DBC 响应式驱动。❌不适合：CPU 密集型任务，瓶颈在 CPU 计算，没有 IO 等待，线程无法释放复用，几乎没有收益。MySQL 全文索

原创 布隆过滤器原理

布隆过滤器主要是有bit数组和多个hash函数组成。bit数组的大小一般没有固定值，但是数据量过大会有误差然后它存储是将一个key经过多次hash函数每次都得出一个值然后再相应的位图位置进行置一，然后这个key再次查询会在布隆过滤器里面看有没有，有的话就放行但是会有误差。

原创 MyBatis‑Plus & MyBatis‑Flex 区别

做日志、监控、数据权限。

原创 为什么SSE无法代替Webscoket

底层都是 TCP 网络，只是上层应用协议、连接模型不一样。

原创 线上耗时问题排查

【代码】线上耗时问题排查。

原创 ConcurrentHashMap、synchronized经典的应用

【代码】ConcurrentHashMap、synchronized经典的应用。

原创 Java里的Json

单个{}一组[]字符串、实体、上面两个容器互相转换 → JSON 工具类；结构固定写实体类，结构动态、字段不确定、解析第三方报文，再用 JSONObject + JSONArray。

原创 Stream流式编程

拆成单层流（一个元素变多个元素），和。，常用于：求和、求乘积、字符串拼接。逐个消费元素，做输出、执行逻辑。返回流中元素总个数，返回值。把所有元素反复合并为。

原创 死锁，慢sql排查，mysql死锁

又循环等待对方释放，且事务不提交锁就不会释放，最终形成死锁。拆分大 SQL单条 SQL 逻辑过杂、关联表过多，拆成分多条简单 SQL。锁等待 / 阻塞：缩短事务时长，事务内不做耗时业务，避免长事务锁表。大批量统计：离线走定时任务 / 数仓，线上不做复杂聚合统计。大表分页 / 查询限制单次查询数据量，避免一次性拉取全表。看执行计划，定位：全表扫描、索引失效、临时表、文件排序。限制返回行数接口层面做分页、条数限制，禁止全表遍历。，只查需要字段，减少 IO 与网络传输。读压力大：主库写，从库读，分摊查询压力。

原创 连接池+虚拟线程

A：线上采用固定连接池，maximum-pool-size 设 10~25，minimum-idle 和最大值一致，idle-timeout=0 禁止回收空闲连接，max-lifetime 小于 MySQL 超时时间，避免断连。A：先排查慢 SQL、事务过长、循环查库，加缓存；A：连接池内连接生命周期大于数据库空闲超时，连接被 DB 断开，池内残留无效连接。A：会触发连接频繁扩容、销毁，产生性能抖动，生产建议固定连接数。，连接被 DB 断开，连接池持有失效连接。，使用完毕归还，而非每次新建。

原创 如何进行线上接口耗时统计

取出之前存的起始纳秒，拿当前 nano 减去起始数值，换算成毫秒，就是整个接口总耗时；缺点: 精度有限，受服务器时间影响（如果第一次是北京时间，然后服务器时间被调整了第二次的结尾的时间戳就不匹配了就有误差了）postHandle 只在正常无异常、没返回前触发，异常不会走，所以。请求经过 Servlet、分发器，还没进到接口业务代码，在这里。使用AOP解决了上面那些的代码侵入缺点，然后和他们联用。提供纳秒级别的测量精度，而且不受服务器时间影响。缺点：需要进行单位转换，代码侵入性强。自动注册，无需额外配置类。

原创 Redis为什么不适合做持久化和DB的区别在哪里

✅ Redis 适用：热点缓存、临时会话、活动计数、排行榜，允许少量数据丢失，RDB+AOF 仅用来缓存故障重启快速恢复；✅ MySQL 适用：订单、用户资产、财务流水等核心业务持久化，要求已写入数据永久落地、零丢失。

原创 慢sql排查，AQS是怎么实现锁的

AQS 通过一个表示锁状态，用CAS修改 state 实现加锁；抢不到锁的线程被封装成 Node 加入双向同步队列，并通过LockSupport.park () 阻塞；释放锁时，将 state 置 0，并通过unpark唤醒队列中的后继线程；可重入则是通过判断持有锁线程是否为当前线程，并对 state 累加实现。

原创 为什么构造器注入碰见循环依赖就会失效，那为什么还要用构造器注入，它的好处是什么。

构造器注入在实例化阶段就需要依赖，对象还没new出来，无法放入三级缓存，还没走到初始化流程就已经死锁，缓存根本用不上。依赖绝对不为 null，避免空指针可用 final 修饰，不可变、线程安全不依赖 Spring，测试方便依赖清晰，可读性强暴露循环依赖，优化设计符合 Java 规范，Spring 官方推荐。

原创 Spring代理类为何依赖注入失效？

B 类的 Bean 是完整的、注入好的；代理 A 只是继承了 B 类，自己没被注入，所以字段为空；所以必须拿着原来那个 B 的 Bean 去调用方法，才能正常运行。

原创 Spring源码的解析

这一步，就是相当于new这个容器，然后也会正常的去执行他的构造函数也就是对应类的构造函数就会执行（以及父类构造函数链）。当scope里面加这个的时候每次get的就是新的实例，也就是说是多例模式每次获取都是new一个新的而不是用那个旧的了，或者说而不是一直用那一个了。大家在spring框架中都知道加注解，还有ioc容器，还有一开始就会加载配置类，然后自动创建对象放入ioc中，这些是怎么完成的呢？这是输出：输出都是同一个对象也就是对应的单例bean。

原创 Java面经

version 存在两个地方：Token 里 + Redis 里鉴权只比 version，不比 Token 字符串改密码 = version +1，旧 Token 全部作废Redis Key 不过期或长期，每次访问续期Key 删了 = 自动登出，重新登录即可。

原创 队列的一些场景题以及处理方式

用分布式锁防并发，用数据库状态做幂等，用 CAS 做最终兜底，用手动 ACK 保证消息可靠性，用重试 + 死信避免死循环，从根源彻底防止消息重复消费。分布式锁防并发，状态幂等防重复，CAS 兜底防锁超时，三层防护层层兜底，从根源彻底杜绝消息重复消费。消息到 Broker 后，从内存 → 写入磁盘的过程。

原创 JAVA面试问题

死信交换机、死信队列、延迟队列，全都是普通交换机、普通队列，没有特殊类型队列 → 交换机 = 指向（靠配置名字，跟 routing key 无关）交换机 → 队列 = 绑定（绑定时才带 routing key）routing key 只有生产者发消息时才有用，消费者根本不用管死信队列：业务队列指向死信交换机 → 死信交换机绑定死信队列（存死信用）延迟队列：自定义队列指向交换机 → 交换机绑定业务队列（过期后直接消费）一个交换机可以绑多个队列，绑的顺序无所谓，只看角色用途建一个普通队列。

原创 Java动态代理和反射以及自定义异常类和全局异常处理器

反射能干三件最核心的事通过 Class 动态创建对象通过 Method 动态执行方法（核心就是invoke通过 Field 动态读写、填充字段遇到 private 怎么办？不管是私有字段、私有方法、私有构造器，反射默认无权访问，会报错作用是关闭权限检查，让反射可以强行操作私有成员Spring IOC 创建 Bean 靠什么？Spring 扫描类，读取字节码，拿到全部信息根据 Class，用反射创建对象，放进 IOC 容器（Map）依赖注入（@Autowired 填充字段）是怎么实现的？

原创 事务失效的几种情况以及是为什么（详解）

MySQL 的 MyISAM 引擎就没有事务功能，不管你 Spring 事务怎么写、代理正不正常，都不可能回滚。只有 InnoDB 引擎才支持事务。你在事务方法里把异常 catch 住，又不往外抛，Spring 根本不知道出错了，就不会回滚。新开线程去调用事务方法，新线程拿不到原来的事务，也走不到事务上下文，事务直接失效。，继承你要拦截的那个类（比如 UserService）AOP 切面没被执行，事务、日志等增强逻辑直接失效。生效，没加的话注解等于白写。Spring 事务是。Spring 事务是。

原创 JAVA面经

用ArrayList：大量查询、遍历，很少中间增删用LinkedList：频繁头尾增删，或当作队列 / 栈使用。

原创 Java小厂面经

循环依赖这种现象是怎么产生的（怎么解决）（是设计问题还是架构问题）有没有用过ai IDE，感觉有哪些地方它做的不好吗。遇到了哪些困难，感觉哪些地方的实现是困难的。异常怎么处理，有没有了解过全局异常处理器。cocounthashmap底层和扩容。key hash可以用来存储哪些数据。sql怎么进行优化的实习项目中。redis有哪几种数据类型。

原创 对Langchain4j的补充以及与springAi的对比

开箱即用的AiServices，本身就支持大量自定义，一行配置就能改，不用重写逻辑// 自定义系统提示词，给Agent定专属的行为规范（比如你的代码生成规范）.systemMessageProvider(ctx -> "你是一个专业的低代码平台开发助手，必须严格遵守以下规范：1. 生成的代码必须是Vue3+TS；2. 生成代码前必须先确认需求边界；3. 代码生成后必须先做语法校验，再执行后续操作...")// 自定义最大循环次数，防止死循环// 自定义超时时间。