大数跨境

Java面试速通(5)| JVM 全解:内存 · GC · 类加载 · 调优|16 题速通

Java面试速通(5)| JVM 全解:内存 · GC · 类加载 · 调优|16 题速通 种子AI编程学习
2026-09-16
5
导读:🔸 中级难度📚 JVM 与调优「Netty 为什么快?零拷贝到底拷贝了几次?
🔸 中级难度📚 JVM 与调优

「Netty 为什么快?零拷贝到底拷贝了几次?」<br/>这两问能把「背过 IO 模型」和「真写过网络程序」的人区分开。本篇上半段讲透底层——select/poll/epoll 三代的演进与 epoll 快的真正原因、LT 与 ET 的取舍、零拷贝到底省掉了哪几次拷贝;中段进 Netty——Reactor 线程模型、ByteBuf 凭什么比 ByteBuffer 好、粘包拆包怎么解、著名的空轮询 Bug;末段讲 RPC——一次调用的全链路、Dubbo 架构与 SPI、负载均衡策略选型、序列化协议怎么挑。12 题、每题约 350 字。

🗂️ 本篇速查索引(一屏总览)

题号
一句话结论
Q01
BIO 阻塞、NIO 轮询、AIO 回调;生产主流是 NIO
Q02
epoll 用红黑树存 fd + 就绪链表,不用每次全量遍历
Q03
LT 会反复通知,ET 只通知一次且必须读完
Q04
mmap 省 1 次 CPU 拷贝,sendfile 省 2 次
Q05
Boss 接活、Worker 干 IO、业务线程池,三组分治
Q06
ByteBuf:双指针免 flip、池化、引用计数、切片零拷贝
Q07
LengthFieldBasedFrameDecoder:长度字段定帧
Q08
IdleStateHandler + 心跳;空轮询靠重建 Selector
Q09
代理 → 序列化 → 寻址 → 传输 → 反序列化 → 返回
Q10
Dubbo 五角色 + SPI 扩展机制(@SPI/@Adaptive)
Q11
随机/轮询/加权/最少活跃/一致性哈希
Q12
对外 JSON、内部 ProtoBuf、Dubbo 默认 Hessian2
读法建议:Q01–Q04 是 IO 底层四连问,Q02、Q04 最考深度;Q05、Q06 是 Netty 岗必答题;Q09 一次 RPC 全链路是综合性大题,适合用来收尾展示全局观。

① IO 模型

Q01🔸 中级

🎙️ 面试官:BIO / NIO / AIO 有什么区别?

💬 面试者:

先统一定义:一次 IO 操作分两阶段——① 等待数据准备好(数据从网卡到内核缓冲区);② 数据从内核缓冲区拷贝到用户空间。各种 IO 模型的差别就在这两阶段谁阻塞、怎么阻塞。

BIO(同步阻塞):两个阶段都阻塞。read() 调下去线程就卡死,直到数据来了拷完才返回。后果:每个连接都要一个线程,连接多了线程就爆了(线程是宝贵资源,默认 1MB 栈)。适用场景:连接数少且固定,简单好写(这是 BIO 唯一的优势)。

NIO(同步非阻塞):阶段①不阻塞——read() 立刻返回,没数据就返回 0,线程可以去干别的;但阶段②(拷贝数据)仍然是同步阻塞的,所以叫「同步」非阻塞。关键:靠 Selector 多路复用器一个线程监听成千上万个连接,谁就绪了就处理谁,这是 Java NIO 的精髓(Redis、Netty、Kafka 都靠它)。缺点:编程复杂(要处理半包、事件循环、Selector 空轮询 Bug)。

AIO(异步非阻塞):两阶段都不阻塞——发起 read() 时直接返回,等内核把数据读完并拷贝好再回调通知你(真正的「干完叫我」)。但现实很骨感:Linux 下的 AIO 实现并不成熟(底层还是用 epoll 模拟的),Java AIO 在 Linux 上性能并不比 NIO 好,所以生产上主流仍是 NIO(Netty),AIO 用得很少(Windows 的 IOCP 才是真异步)。

一句话记忆:BIO 傻等、NIO 轮询就绪、AIO 干完通知;Java 网络编程的实际答案是 NIO + 多路复用。

📌 速记:BIO 阻塞等、NIO 轮询就绪、AIO 干完通知;Linux 下 AIO 实际仍是 NIO。

Q02🔺 高级

🎙️ 面试官:select / poll / epoll 的区别?为什么 epoll 快?

💬 面试者:

三者都是 IO 多路复用机制,解决的问题一样:一个线程同时监视多个 fd(文件描述符),哪个就绪了就处理哪个。区别在实现效率和上限。

select(1983):① fd 数量有硬上限(FD_SETSIZE,通常 1024,改要重新编译内核);② 每次调用都要把整个 fd 集合从用户态拷贝到内核态(O(n) 拷贝);③ 返回后只告诉你「有 n 个就绪」但不告诉你是谁,你得自己遍历全部 fd 才能找出就绪的(O(n) 遍历)。连接越多,这两份 O(n) 越要命。

poll(1997):只解决了上限问题(改用链表,理论上无限制),但 O(n) 拷贝和 O(n) 遍历一个没改,本质没进步。

epoll(2002,Linux 2.6):三招彻底解决。① 红黑树记 fd——epoll_ctl 把要监听的 fd 一次性注册进内核的红黑树,之后 epoll_wait 不用再重复传 fd 集合(省掉每次的 O(n) 拷贝)。② 就绪链表返回结果——内核在 fd 就绪时通过回调把它挂进「就绪链表」,epoll_wait 直接返回这个链表,不需要遍历全部 fd(O(n) 遍历 → O(活跃连接数))。③ mmap 共享内存——内核与用户空间共享一块内存传递就绪事件,再省一次拷贝。

一句话总结:select/poll 是「轮询」——每次都要把全部 fd 端给内核、再挨个问一遍;epoll 是「回调」——fd 一次性交给内核,谁就绪内核主动挂链表通知你。所以连接数多但活跃连接少的场景(典型就是海量长连接,比如 IM、网关),epoll 性能近乎不随连接数下降,而 select/poll 会线性劣化。

📌 速记:select/poll 每次全量拷贝+遍历 O(n);epoll 红黑树 + 就绪链表,O(1) 拿就绪。

Q03🔺 高级

🎙️ 面试官:epoll 的 LT 与 ET 模式有什么区别?Netty 用的是哪种?

💬 面试者:

LT(Level Triggered,水平触发,默认):只要 fd 还处于就绪状态(缓冲区里还有数据没读完),每次 epoll_wait 都会持续通知你。好处是安全、好写——这次没读完没关系,下次还会提醒你,数据不会丢。坏处是如果一直不读完,会反复触发,浪费 CPU。

ET(Edge Triggered,边缘触发):只在「状态发生变化」的那一刻通知一次——比如从无数据到有数据。之后即使缓冲区里还剩数据,也不会再通知。所以 ET 模式下你必须在一次通知里把数据全部读完,否则剩下的数据要等下次有新数据到来时才会被处理(这就埋下了丢数据的隐患)。

ET 的正确写法:必须配合非阻塞 IO + while 循环读到 EAGAIN——也就是循环 read(),直到返回 EAGAIN(表示「暂时没数据了」)才停。如果 fd 是阻塞的,最后一次 read() 会直接卡死线程。

Netty 用的是 ET 吗:严格说 Netty 在 epoll 传输层(native transport,即 EpollSocketChannel)用的是 ET,并且正是按上面的规范写的——把 fd 设为非阻塞,在事件循环里循环读取直到 EAGAIN。但在 NIO 传输层(NioSocketChannel,基于 JDK 的 Selector)用的是 LT(JDK 的 Selector 只支持 LT)。Netty 之所以敢用 ET,是因为它自己把「必须读完」的循环逻辑封装好了,业务代码不用关心。

追问:ET 一定比 LT 快吗?不一定——ET 减少了重复通知次数,在大流量下 epoll_wait 调用更少,理论更省;但 ET 编程复杂、易出 Bug。对大多数应用,LT 的性能已经足够,Redis 用的是 LT(它在一次事件里也会尽量读完)。

📌 速记:LT 没读完会一直通知(安全);ET 只在状态变化时通知一次(必须一次读完)。

Q04🔺 高级

🎙️ 面试官:什么是零拷贝?mmap 与 sendfile 的区别?

💬 面试者:

先看清传统 IO 有多浪费——以「读文件再通过网络发出去」(比如静态服务器)为例,传统方式要 4 次拷贝 + 4 次上下文切换:① 磁盘 → 内核缓冲区(DMA);② 内核缓冲区 → 用户缓冲区(CPU 拷贝,read());③ 用户缓冲区 → Socket 缓冲区(CPU 拷贝,write());④ Socket 缓冲区 → 网卡(DMA)。其中②③这两次 CPU 拷贝其实毫无意义——数据根本没在用户态加工过,只是「过个手」。

零拷贝的目标就是砍掉这两次无意义的 CPU 拷贝(注意:零拷贝指的是「零 CPU 拷贝」,DMA 拷贝仍然有)。

mmap(内存映射):把内核缓冲区映射到用户空间,用户态和内核态共享同一块内存,于是第②步不需要了。但第③步(用户缓冲区 → Socket 缓冲区)还在,因为数据最终还是要进 Socket 发送缓冲区。所以 mmap 省 1 次 CPU 拷贝(剩 3 次拷贝:DMA + CPU + DMA)。适用场景:需要对数据做加工(如 RocketMQ/Kafka 用 mmap 读写日志文件,因为它要解析消息内容)。

sendfile(Linux 2.1+):直接在内核态完成「文件缓冲区 → Socket 缓冲区」的拷贝,数据完全不经过用户态。所以 ②③ 两步全砍掉,省 2 次 CPU 拷贝(只剩 2 次 DMA)。适用场景:数据不需要任何加工,原样转发(静态文件服务器、下载服务)。sendfile 就是 Kafka 高吞吐的核心原因之一——消费者拉消息时,消息从磁盘文件直接送进网卡,几乎不占 CPU。

终极形态(Linux 2.4+ 的 sendfile + SG-DMA):连「内核缓冲区 → Socket 缓冲区」这次拷贝都省了——只把数据的位置和长度描述符拷进 Socket 缓冲区,DMA 直接从内核缓冲区读数据发到网卡,此时 CPU 拷贝次数为 0,真正做到「零拷贝」。

方式
CPU 拷贝次数
数据过用户态
典型场景
传统 read + write
2 次
是
需要加工数据
mmap + write
1 次
是(共享内存)
Kafka/RocketMQ 存消息
sendfile
0~1 次
否
静态文件、下载转发
sendfile + SG-DMA
0 次
否
Kafka 消费、CDN
📌 速记:零拷贝是减少 CPU 拷贝次数:mmap 省一次、sendfile 省两次。

② Netty

Q05🔸 中级

🎙️ 面试官:Netty 的线程模型是怎样的?它为什么高性能?

💬 面试者:

Netty 用的是「主从 Reactor 多线程模型」,这是 Reactor 模式的终极形态。三组角色,各司其职:① BossGroup(主 Reactor)——通常只 1 个线程,只负责接受客户端连接(accept),拿到连接后注册给 WorkerGroup;② WorkerGroup(从 Reactor)——默认线程数 = CPU 核数 × 2,负责连接上的读写 IO 事件;③ 业务线程池(DefaultEventExecutorGroup)——耗时业务逻辑丢到这里跑,绝不能阻塞 Worker 线程。

为什么高性能(五点,按重要性排):① 基于 NIO + epoll,IO 多路复用——一个线程管成千上万连接,不是「一连接一线程」,这是根本。② 无锁化的串行设计——每个 Channel 从生到死只绑定一个 EventLoop 线程,所有事件都在这一根线程里串行执行,所以 Handler 里不需要加锁(这是 Netty 最重要的一条设计,也是它比自己写 NIO 强得多的原因)。③ 零拷贝——CompositeByteBuf 合并多个 buffer 而不复制、slice() 共享内存、FileRegion 用 sendfile 发文件、堆外直接内存。④ 内存池化——PooledByteBufAllocator 复用 ByteBuf(类似线程池,避免频繁申请释放和 GC)。⑤ 无锁队列 + 精细的对象复用——减少 GC 压力。

必须避开的坑:千万不要在 Netty 的 IO 线程里执行耗时操作(查库、调外部接口、同步等待)——因为一个 EventLoop 要服务多个连接,你卡住它,它名下所有连接全部卡死。正确做法是丢给业务线程池,或者用 Promise 异步回调。

📌 速记:主从 Reactor:Boss 接连接、Worker 干 IO、业务丢线程池,各司其职。

Q06🔺 高级

🎙️ 面试官:Netty 的 ByteBuf 相比 JDK 的 ByteBuffer 好在哪里?

💬 面试者:

四个维度全面胜出:

① 读写指针分离,不用 flip()——JDK 的 ByteBuffer 只有一个 position 指针,读模式切写模式必须调 flip(),忘了就会读脏数据或写不进去(这是 NIO 最经典的 Bug 来源)。ByteBuf 有两个指针:readerIndex 和 writerIndex,读写各走各的,永远不用 flip。

② 动态扩容——ByteBuffer 的容量固定,写超了直接抛 BufferOverflowException,你得手动检查并新建更大的 buffer。ByteBuf 写入时自动扩容(默认到 4MB 为止),写代码时完全不用管容量。

③ 池化 + 引用计数——ByteBuffer 每次都新建,堆外的还得等 GC 或手动清理,容易内存泄漏。ByteBuf 有 PooledByteBufAllocator 池化复用(大幅降低分配开销和 GC),并用「引用计数」管理生命周期——retain() 加一、release() 减一,归零才回收(责任在最后使用它的那个 Handler,忘了 release() 就是堆外内存泄漏)。

④ 零拷贝 API——slice()(切一片共享内存,不复制)、duplicate()、CompositeByteBuf(把多个 ByteBuf 逻辑上拼成一个,物理上不复制,组装协议包头包体时极有用)。JDK 的 ByteBuffer 只能靠 slice() 且不支持组合。

补充:ByteBuf 还支持堆内(HeapByteBuf)和堆外(DirectByteBuf)两种——堆外内存不走 JVM 堆,省一次「堆内存 → 直接内存」的拷贝,网络 IO 性能更好(Netty 默认用堆外 + 池化);代价是不受 GC 管理,必须靠引用计数手动释放。

📌 速记:ByteBuf = 读写双指针 + 池化 + 引用计数 + 零拷贝切片,全面胜过 ByteBuffer。

Q07🔸 中级

🎙️ 面试官:Netty 是怎么解决粘包 / 拆包的?

💬 面试者:

思路:Netty 提供了一组「解码器(Decoder)」,它们本质上就是把 TCP 收到的字节流,按规则切成一个个完整的业务报文(帧),再交给上层 Handler。业务代码拿到的永远是一个完整报文,不用自己管边界。

四种内置解码器:① FixedLengthFrameDecoder——定长,按固定字节数切(简单但浪费)。② LineBasedFrameDecoder / DelimiterBasedFrameDecoder——按分隔符(如 )切,适合文本协议。③ LengthFieldBasedFrameDecoder(最常用,工业标准)——报文头里带长度字段,这是 Dubbo、RocketMQ 等框架的做法。④ 自定义 ByteToMessageDecoder——自己实现 decode(),适合私有协议。

LengthFieldBasedFrameDecoder 的五个参数(面试爱问):maxFrameLength(最大帧长,防恶意超大包打爆内存,必填)、lengthFieldOffset(长度字段从第几个字节开始)、lengthFieldLength(长度字段本身占几字节:1/2/4/8)、lengthAdjustment(长度字段的值是否包含长度字段自身和包头,用于修正)、initialBytesToStrip(解析后跳过几个字节——通常跳过整个包头,让业务 Handler 只拿到数据体)。

为什么必须有 maxFrameLength:如果不限制,攻击者发一个长度字段伪造为几个 G 的包,服务端会一直等/一直分配内存,直接 OOM。这是网络编程的必备安全意识。

// 典型私有协议:| 魔数 2B | 版本 1B | 长度 4B | 数据体 N B |
// lengthFieldOffset=3:长度字段从第 3 个字节开始(跳过魔数2 + 版本1)
// lengthFieldLength=4:长度字段本身占 4 个字节
// lengthAdjustment=0 :长度字段的值就是数据体长度,无需修正
// initialBytesToStrip=7:解析后跳过 2+1+4=7 字节的头部,只留数据体
pipeline.addLast(new LengthFieldBasedFrameDecoder(
1024 * 1024, // maxFrameLength:最大 1MB,防超大包打爆内存
3, // lengthFieldOffset
4, // lengthFieldLength
0, // lengthAdjustment
7)); // initialBytesToStrip
pipeline.addLast(new MyBizHandler()); // 这里拿到的就是一个完整报文
⚠️ 注意:maxFrameLength 必须设置且不能过大。不设的话攻击者只需伪造一个超大长度字段,服务端就会持续等待或疯狂分配内存,直接 OOM——这是私有协议最常见的线上事故。
📌 速记:长度字段解码器:先读长度,再按长度读满一帧,工业标准解法。

Q08🔺 高级

🎙️ 面试官:Netty 怎么做心跳与空闲检测?什么是 epoll 空轮询 Bug?

💬 面试者:

空闲检测:Netty 内置 IdleStateHandler,加进 pipeline 即可,它有三个参数——readerIdleTime(多久没读到数据)、writerIdleTime(多久没写)、allIdleTime(多久没读写)。超时后它不直接断连,而是触发一个 IdleStateEvent 事件,你在自己的 Handler 里 userEventTriggered() 捕获它,自行决定是发心跳还是直接关连接。

心跳机制:① 应用层自己实现——客户端定时发一个极小的心跳包(如 PING),服务端回 PONG;若连续 N 次没收到回应,判定连接已死,主动关闭并重连(长连接必备,因为 TCP 本身无法感知对端掉线——拔网线、断电时不会有 FIN 发过来)。② TCP 层的 SO_KEEPALIVE——默认 2 小时才探测一次,太慢,生产几乎不可用,需要改内核参数,一般不用。

epoll 空轮询 Bug(JDK NIO 的经典 Bug):JDK 的 Selector.select() 本该阻塞直到有事件,但在某些 Linux 内核下会「明明没有事件却立刻返回 0」,导致 while 循环变成空转死循环,CPU 直接飙到 100%。这是 JDK 的 Bug(官方标记为不会修复,理由是「Linux 内核的问题」)。

Netty 怎么规避:计数重建法——Netty 统计 select() 的「空返回次数」,如果在很短时间内连续空返回超过阈值(默认 512 次),就判定触发了空轮询,于是新建一个 Selector,把老 Selector 上注册的所有 Channel 重新注册到新的上,再关掉老的。这个过程对业务透明。这也是「为什么要直接用 Netty 而不是自己写 NIO」的一个硬核理由——这些坑框架已经替你踩过了。

// 服务端:60 秒没读到数据就触发 IdleStateEvent
pipeline.addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS));
pipeline.addLast(new ChannelInboundHandlerAdapter() {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
if (evt instanceof IdleStateEvent) {
// 读空闲:认为对端已失联,直接关连接(客户端需实现重连)
ctx.close();} } });

// 客户端:30 秒没写数据就主动发一次心跳包
pipeline.addLast(new IdleStateHandler(0, 30, 0, TimeUnit.SECONDS));
📌 速记:IdleStateHandler 做空闲检测;空轮询靠重建 Selector 规避。

③ RPC

Q09🔸 中级

🎙️ 面试官:一次 RPC 调用,完整链路发生了什么?

💬 面试者:

RPC 的目标:让调用远程服务像调用本地方法一样简单。核心是把「方法调用」翻译成「网络请求」。完整链路八步:

① 本地调用——业务代码 orderService.create(order),这里 orderService 其实是个动态代理对象(不是真正的实现类)。② 代理拦截——JDK 动态代理(或 CGLIB/ByteBuddy)拦住这次调用,拿到接口名、方法名、参数类型和参数值。③ 序列化——把方法名、参数等序列化成字节数组(JSON / Hessian / ProtoBuf)。④ 服务发现(寻址)——从注册中心(Nacos/Zookeeper)拿到该服务所有可用实例的 IP 列表(本地通常有缓存)。⑤ 负载均衡——从实例列表里按策略挑一个(随机 / 轮询 / 最少活跃等)。⑥ 网络传输——通过 Netty(NIO 长连接)把请求发过去(通常会先建连接池,复用连接,避免每次握手)。⑦ 服务端处理——服务端 Netty 收到请求 → 反序列化 → 按「接口 + 方法」从本地服务注册表找到真正的实现类 → 反射调用 → 拿到结果。⑧ 返回结果——结果序列化后发回,客户端反序列化,代理对象把结果返回给业务代码,整个调用看起来就像本地方法调用一样。

追问常客:RPC 和 HTTP 有什么区别?——① 协议层:RPC 可以自定义协议(报文头更紧凑,可带长度字段解决粘包,性能更好),HTTP 是通用标准协议(头信息冗余,但通用性强、跨语言零成本);② 服务治理:RPC 框架(Dubbo/gRPC)自带服务发现、负载均衡、熔断限流、优雅上下线,HTTP 这些都要自己搭(Spring Cloud 就是补这块的);③ 使用场景:内部服务间调用用 RPC(性能 + 治理),对外暴露给第三方用 HTTP(通用 + 穿透防火墙)。

📌 速记:RPC = 动态代理 + 序列化 + 网络传输 + 服务发现 + 负载均衡。

Q10🔸 中级

🎙️ 面试官:Dubbo 的架构是怎样的?什么是 SPI 机制?

💬 面试者:

五个角色:① Provider 服务提供者(启动时向注册中心注册自己);② Consumer 服务消费者(启动时订阅服务,拿到提供者列表缓存在本地,注册中心挂了也不影响已有调用);③ Registry 注册中心(Zookeeper / Nacos,负责服务发现;注意它不是转发请求的,只做地址登记);④ Monitor 监控中心(统计调用次数和耗时);⑤ Container 服务运行容器。调用时 Consumer 直接连 Provider,不经过注册中心——这是 Dubbo 的关键设计,注册中心只做「查号台」。

Dubbo 的分层与设计:① 动态代理把接口调用转为 Invoker;② Cluster 层做负载均衡、容错、路由;③ Protocol 层负责具体的协议编解码(默认 Dubbo 协议,还有 HTTP/gRPC 等);④ Transport 层基于 Netty 做网络传输;⑤ Serialize 层做序列化。每一层都可替换,靠的就是 SPI。

SPI(Service Provider Interface)是什么:一种「插件式扩展」机制——框架定义接口,实现方按约定写配置文件,框架运行时自动发现并加载实现,无需改框架源码。Java 标准 SPI 是 META-INF/services/接口全限定名 文件里写实现类,用 ServiceLoader 加载。

Dubbo 为什么不用 JDK SPI 而自己实现:JDK SPI 有三个硬伤——① 一次性实例化所有实现类(不管用不用,浪费资源);② 没有 IoC 和 AOP 支持;③ 无法按名字获取指定实现,也不支持默认值。Dubbo SPI 补齐了这些:① 按 key 加载——配置文件写成 dubbo=com.alibaba.dubbo.rpc.protocol.dubbo.DubboProtocol(key = 实现名),可以按需加载指定 key 的实现;② 支持自适应扩展 @Adaptive——在运行时根据 URL 参数动态决定用哪个实现(比如 protocol=grpc 就自动选 gRPC 实现);③ 自动包装(Wrapper)——实现类可以被自动套一层装饰器,这是 Dubbo 的 Filter 拦截链、监听器机制的基础;④ 支持 IoC 注入(setXxx 自动注入扩展点)。

一句话:SPI 是 Dubbo 的灵魂——协议、序列化、负载均衡、注册中心所有组件都是可替换的扩展点,这就是 Dubbo 高度可扩展的原因。

📌 速记:Dubbo 五角色:Provider/Consumer/Registry/Monitor/Container;SPI 是扩展灵魂。

Q11🔸 中级

🎙️ 面试官:常见的负载均衡策略有哪些?各自适用场景?

💬 面试者:

① 轮询(RoundRobin)——按顺序一个个分。优点:绝对均匀。缺点:不管服务器性能差异和实际负载。适用:所有机器配置相同、请求耗时相近。

② 加权轮询(WeightedRoundRobin)——给性能好的机器更高权重,分到更多请求。适用:机器配置不一致(新老机器混布),这是最常用的一档。

③ 随机(Random)+ 加权随机——Dubbo 的默认策略。为什么随机反而成了默认?因为在请求量足够大时,随机的分布和轮询一样均匀,但实现更简单、没有状态、无锁、性能更好。加权版本还能兼顾机器性能差异。

④ 最少活跃数(LeastActive)——把请求给当前正在处理的请求数最少的那台(活跃数 = 处理中的请求数)。这才真正考虑了「实际负载」:处理快的机器会更快释放活跃数,自然拿到更多请求。适用:请求耗时差异大的场景(有的请求 10ms,有的 3s),这是 Dubbo 里最「聪明」的策略,强烈推荐。

⑤ 一致性哈希(ConsistentHash)——相同参数的请求总是落到同一台机器。核心价值:① 有状态服务(需要会话保持,比如本地缓存命中率);② 灰度发布、压测流量隔离。关键设计:引入虚拟节点(一台物理机映射成 150 个虚拟节点),解决数据倾斜;节点下线时只影响环上相邻的一小段请求,不会像普通取模 hash % N 那样全量重分布(这是它最大的优势)。

⑥ 最短响应时间(ShortestResponse)——按历史平均响应时间加权,快的机器多分。适用:对延迟敏感的服务。

选型建议:默认「加权随机」或「最少活跃」;要会话保持/灰度用「一致性哈希」;机器配置一致且简单用「轮询」。注意:负载均衡一般在客户端做(Dubbo、Spring Cloud LoadBalancer 都是客户端负载均衡——消费者本地持有全部服务地址,自己挑一台发,少一跳网络),而 Nginx 是服务端负载均衡。

📌 速记:轮询/随机/加权/最少活跃/一致性哈希,按场景选。

Q12🔺 高级

🎙️ 面试官:序列化协议怎么选?JSON / Hessian / ProtoBuf 的区别?

💬 面试者:

三个评价维度:① 性能(序列化速度 + 序列化后的体积);② 跨语言能力;③ 可读性 / 可调试性。三者不可兼得,选型就是权衡。

JSON:优点——可读性好、跨语言无敌、生态最全(前后端、HTTP API 的事实标准),调试方便(直接肉眼看得懂)。缺点——体积大(key 名重复存、无类型信息),性能差(字符串解析慢),不支持复杂类型(没有 Date、BigDecimal 的原生表达,Long 精度在 JS 里还会丢)。适用:对外 HTTP API、配置文件、日志。

Hessian:二进制、跨语言、体积比 JSON 小不少,能表达复杂对象和引用。Dubbo 默认的序列化方式(Hessian2)。优点:平衡性好——比 JSON 快且小,比 ProtoBuf 简单(不用写 schema)。缺点:性能和体积都不如 ProtoBuf;历史上各语言实现有兼容性问题。适用:Dubbo 等 RPC 框架的默认选择。

ProtoBuf(Google):优点——性能和体积都是碾压级(二进制紧凑、无冗余 key、编码解码纯位运算),比 JSON 快 5~10 倍、体积小 3~5 倍;强 schema(xx.proto 文件)+ 自动生成代码,类型安全;向后兼容做得极好(字段编号机制,加字段不破坏老版本,这是它比 Thrift/Avro 更流行的关键)。缺点——需要预定义 .proto 并生成代码(开发流程变重),二进制不可读,调试要靠工具。适用:内部服务间高性能 RPC(gRPC 的默认协议)、海量数据存储、Kafka 消息体。

选型建议:对外接口用 JSON(通用 + 可读);内部 RPC 默认用 Hessian2(零成本);性能敏感 / 跨语言 / 大数据量场景用 ProtoBuf(gRPC)。另外提醒:不要 Java 原生序列化——性能差、体积大、不能跨语言,而且有严重的安全漏洞(反序列化 RCE,readObject 能直接执行恶意代码),生产上应明确禁用。

⚠️ 注意:Java 原生序列化(Serializable)在生产上必须禁用:① 性能差、体积比 ProtoBuf 大 5 倍以上;② 不能跨语言;③ 最致命的是反序列化漏洞——readObject() 会在反序列化时执行类中的代码,攻击者构造恶意字节流就能远程执行任意命令(RCE),历史上 Fastjson、Jackson、Shiro 都出过同类漏洞。正确做法:用 JSON / ProtoBuf 等纯数据格式,并对反序列化的目标类做白名单校验。
📌 速记:JSON 通用可读、Hessian 平衡、ProtoBuf 极致性能;内部 RPC 首选 ProtoBuf。

📝 本篇小结

① IO 底层记住三句话:select/poll 是轮询(每次全量拷 fd + 全量遍历),epoll 是回调(红黑树存 fd + 就绪链表返回);LT 反复通知安全、ET 只通知一次必须读完;零拷贝省的是「CPU 拷贝」——mmap 省 1 次、sendfile 省 2 次。

② Netty 高性能的四根支柱:NIO 多路复用、一个 Channel 绑定一个 EventLoop 串行无锁、内存池化、零拷贝 API。唯一红线:别在 IO 线程里做耗时操作。

③ RPC 与序列化:一次调用 = 代理 → 序列化 → 寻址 → 负载均衡 → Netty 传输 → 反射调用 → 返回;对外 JSON、内部 Hessian2/ProtoBuf,Java 原生序列化生产禁用。


【声明】内容源于网络
0
0
种子AI编程学习
佛系分享人工智能知识、技术知识、互联网知识,非躺平不内卷的小玩家。
内容 59
粉丝 0
种子AI编程学习 佛系分享人工智能知识、技术知识、互联网知识,非躺平不内卷的小玩家。
总阅读156
粉丝0
内容59