Netty 面试题集

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

Netty跟Java NIO有什么不同，为什么不直接使用JDK NIO类库？

Netty 与 Java NIO 存在如下几个层次的差异：

• 抽象层级和易用性
  • Java NIO 是 Java 的一个低级别的非阻塞I/O实现，提供了通道(Channel)、缓冲区(Buffer)、选择器(Selector)等基础组件。这些组件虽然强大，但使用起来相对复杂，需要我们处理很多底层细节，如缓冲区管理、线程管理、容错等等。
  • Netty 是一个高性能的网络应用框架，基于 Java NIO 构建，提供了更高级别的抽象和丰富的API。它封装了 NIO 的复杂性，让开发者可以更加容易地开发网络应用程序。而且Netty 还提供了对协议编解码器、事件处理、管道管理等高级特性的支持。
• 性能优化和扩展性
  • Java NIO 需要用户自己进行性能优化，如合理配置缓冲区大小、选择合适的线程模型等。
  • Netty 提供了许多性能优化的功能，例如零拷贝、可重用的缓冲区等，同时它的架构允许更加灵活的线程模型配置和更高效的资源利用。
• 协议支持和扩展
  • Java NIO 主要提供了基础的网络通信能力，对于特定协议的支持并不多。
  • Netty 不仅支持 TCP 和 UDP 基础协议，还内置了对 HTTP、WebSocket、SSL 等多种协议的支持，并且可以方便地添加自定义的协议处理器。
• 错误处理和调试：
  • 在 Java NIO 中，错误处理和调试可能比较困难，因为需要深入理解 NIO 的工作原理。
  • Netty 提供了更为友好的错误报告和调试工具，使得我们能更快地定位和解决问题。

Netty 高性能表现在哪些方面？

• 异步和非阻塞I/O
  • Netty 基于 Java NIO，实现了异步和非阻塞I/O操作。这意味着它可以在不阻塞线程的情况下处理多个网络连接，从而减少了线程上下文切换的开销，并提高了资源利用率。
• 零拷贝特性：
  • Netty 实现了零拷贝（Zero-Copy）技术，允许它在不同的I/O操作中直接发送或接收缓冲区的数据，避免了数据在用户态和内核态之间的多次复制，从而提高了I/O效率。
• 高效的缓冲区管理：
  • Netty 提供了高效的缓冲区管理机制，比如重用和池化技术，减少了内存的分配和回收操作，这在处理大量网络请求时尤为重要。
• 优化的线程模型：
  • Netty 允许灵活地配置线程模型，如单线程、多线程或主从多线程模型。这些模型可以根据应用程序的具体需求来优化线程的使用，提高系统的整体性能。
• 各种协议支持
  • Netty 内置了对多种协议的支持，如 HTTP/HTTPS、WebSocket、Google Protocol Buffers 等。这不仅减少了开发者实现这些协议的工作量，而且这些实现是针对性能进行了优化的。
• 优化的数据结构和算法
  • Netty 在其内部使用了许多优化的数据结构和算法，以减少资源消耗，提高处理速度。

Netty 中有哪种重要组件？

Netty 是一个高性能的网络编程框架，它包含了一些核心组件，每个组件都在整个网络通信过程中扮演着重要的角色。下面是 Netty 中的一些关键组件及其介绍：

• Bootstrap / ServerBootstrap

Bootstrap 类是在 Netty 客户端程序中使用的，用于设置客户端的所有配置；ServerBootstrap 是对应的服务器端类。它们都是启动 Netty 应用程序的入口，负责配置整个 Netty 程序，如设置线程模型、选择器、通道类型等。

• Channel

Channel 接口是 Netty 网络操作的核心组件，是 Netty 网络通信的通道，可以执行读写操作。Netty 为不同类型的传输提供了多种 Channel 实现，如 NioSocketChannel 用于 NIO 传输。

• EventLoop 和 EventLoopGroup

EventLoop 是用于处理 Channel 的 I/O 操作线程。一个 EventLoop 可以服务多个 Channel。EventLoopGroup 是 EventLoop 的集合。在 Netty 中，通常会有两个 EventLoopGroup，一个用于接受新的连接（BossGroup），另一个用于处理已接受的连接的数据传输(WorkGroup)。

• ChannelPipeline 和 ChannelHandler

ChannelPipeline 提供了一个容器，通过它可以传递处理网络事件的 Handler 链。每个 Channel 都有自己的 Pipeline。

ChannelHandler 是一个接口，用于处理 I/O 事件或拦截 I/O 操作，并将其转发到其所属的 ChannelPipeline 中的下一个处理器。Handler 可以是编码器、解码器、简单的逻辑处理器等。

• ChannelFuture

ChannelFuture 代表了一个未来的 I/O 操作，可以用它来判断一个操作是否成功完成。它提供了一种异步机制，允许在操作完成后得到通知。

• ByteBuf

ByteBuf 是 Netty 的数据容器，相比 Java NIO 中的 ByteBuffer，它提供了更加强大和灵活的功能，如引用计数、池化等，以及对字节数据的读写操作。

• Decoder 和 Encoder

在 Netty 中，数据在网络中传输通常需要进行编码（发送方）和解码（接收方）。Netty 提供了多种编码器（Encoder）和解码器（Decoder），用于处理不同的数据格式，如字符串、二进制数据、协议消息等。

Netty的线程模型？

Netty 的线程是非常灵活的，支持各种不同的使用场景。

一、基本概念

• 基于事件循环的模型

Netty 使用了基于事件循环（Event Loop）的模型。Event Loop 是一个不断循环的线程，它负责处理所有分配给它的 I/O 事件，如接受新的连接、读取数据、写入数据等。

• EventLoop

EventLoop 在 Netty 中是核心组件之一，它是一个特定于线程的循环，用于处理连接的所有 I/O 操作。每个 EventLoop 都绑定到一个线程，并处理分配给它的所有 I/O 事件。

• EventLoopGroup

EventLoopGroup 是一组 EventLoop 的集合。它负责提供 EventLoop 以处理 Channel 的事件。EventLoopGroup 可以包含一个或多个 EventLoop。

• Boss 和 Worker 线程组

对于服务器端应用，Netty 通常使用两个 EventLoopGroup：BossGroup 和 WorkerGroup。BossGroup 主要负责处理新的客户端连接。WorkerGroup 负责处理与各个客户端连接相关的后续 I/O 操作，如读取数据、发送数据等。

二、线程模型类型

• 单线程模型

在这种模型中，所有的 I/O 操作都由一个单独的 EventLoop（因此是单线程）处理。这个模型适用于小型或者不太复杂的应用程序，因为它简单且避免了线程同步的问题。

• 多线程模型

在多线程模型中，有多个 EventLoop 实例，每个实例绑定到自己的线程。每个连接被分配给一个 EventLoop，因此 I/O 操作可以在多个线程中并行进行。这种模型适用于需要高吞吐量的应用。

• 主从多线程模型（Master-Slave）

这个模型通常用于服务器端。它涉及两组 EventLoopGroup：主（Boss）Group 和从（Worker）Group。

• BossGroup 主要负责处理新的客户端连接。
• WorkerGroup 负责处理已经建立的连接的 I/O 操作，如数据的读写。

当一个新的连接建立时，BossGroup 中的一个 EventLoop 会接受这个连接，并将其注册到 WorkerGroup 的一个 EventLoop。这种模型能够有效地分离连接接受和数据处理的工作，提高性能。

三、线程分配

在 Netty 中，当一个新的 Channel 创建时，它会被分配给一个 EventLoop。这个 EventLoop 从此负责这个 Channel 的所有 I/O 操作，直到 Channel 关闭。这保证了对同一个 Channel 的所有 I/O 操作都由同一个线程处理，简化了并发编程。

Netty中NioEventLoopGroup 默认的构造函数会起多少线程？

在 Netty 中，NioEventLoopGroup 的默认构造函数创建的线程数取决于运行时环境。默认情况下，它会根据服务器的可用处理器（CPU核心）数量来确定线程数，通常为CPU 核心数的两倍。

Netty 为什么要实现自己的 ByteBuf？

Java NIO 的 ByteBuffer 在设计上有几个限制或缺点：

• 模式切换：ByteBuffer 需要利用 flip() 在读模式和写模式之间切换。这种需要手动切换模式的设计增加了使用复杂性，并有可能导致编程错误。
• 无法扩容：ByteBuffer 在创建时就确定了其容量，且之后无法更改。如果需要更大的空间，就必须创建一个新的 ByteBuffer 并将数据复制过去，这种操作效率不高。而且这种缺乏动态扩容的能力，这在处理不可预知长度的数据时会成为限制。
• 内存管理不够灵活：ByteBuffer 不支持引用计数，因此当一个缓冲区被多个组件共享时，管理其生命周期变得复杂。
• 性能问题：在某些情况下，ByteBuffer 的操作可能会导致不必要的内存复制，从而影响性能。例如，compact() 方法在进行压缩时就会进行内存复制。

为了解决 Java NIO 的 ByteBuffer 在网络编程中存在的一些局限性和效率问题，Netty 实现了自己的 ByteBuf。相比 Java NIO 的 ByteBuffer，Netty 的 ByteBuf 提供了多种性能优化和增强的功能，主要包括：

1. 引用计数：ByteBuf 实现了引用计数机制，这允许有效地管理内存，尤其是在缓冲区需要在多个地方共享时。当引用计数降到零时，缓冲区可以被自动释放，从而避免了内存泄漏的问题。
2. 读写索引分离：ByteBuf 提供了两个独立的索引：一个用于读操作，一个用于写操作。这种分离使得读写操作更加灵活，不需要像 ByteBuffer 那样在读模式和写模式之间切换。
3. 池化：Netty 支持缓冲区池化，可以重用常用的缓冲区，减少内存的分配和回收操作。在高负载的网络应用可以明显提高性能和降低垃圾回收的压力。
4. 零拷贝能力：ByteBuf 支持零拷贝操作，能够在不同的缓冲区间高效转移数据，避免了不必要的内存复制。
5. 支持容量扩展：ByteBuf 提供了动态扩展能力，缓冲区可以根据需要自动扩展容量，而不需要显式地重新分配和复制数据。
6. 更丰富的API：ByteBuf 提供了比 ByteBuffer 更丰富和用户友好的 API，使得处理不同类型的数据（如字节、字符、整数等）更加方便。

Netty 为什么要实现自己的 Channel？

Netty 实现了自己的 Channel 主要是为了解决 Java NIO 中原生 Channel 类的局限性，并且增加了一些特性来满足高性能网络编程的需求。

Java NIO 中原生 Channel 有如下几个缺陷：

• 缺乏高级特性：Java NIO 的 Channel 缺乏一些对高性能网络通信至关重要的高级特性，如零拷贝、异步读写操作、通道池化等。
• 错误处理不够友好：在 Java NIO 中，错误处理通常是通过捕获和处理异常来进行的。这种方式在复杂的网络环境中可能导致代码难以管理和维护。
• 缺少扩展性和灵活性
• 缺少统一的数据处理流程：在 Java NIO 中，数据的读取和写入需要手动管理，缺少像 Netty 那样的统一和灵活的数据处理流程（如 Pipeline 和 Handler 机制）。
• 资源管理：在 NIO 中，正确管理 Channel 的生命周期和相关资源（如缓冲区）可能比较复杂，特别是在涉及多个通道和线程的情况下。

相比 Java NIO 的原生 Channel，Netty 提供的 Channel 具有如下几个优势：

• 更高级的抽象：Netty 的 Channel 提供了比 Java NIO 的 Channel 更高级的抽象。它封装了底层的网络通信细节，使得我们可以更专注于业务逻辑的实现，而不是复杂的网络操作。
• 统一的 API：Netty 提供了统一的 API 来处理不同类型的传输，如 TCP 和 UDP。这种统一性使得在不同类型的网络协议间切换变得更加容易。
• 更好的性能：Netty 的 Channel 是为高性能网络编程设计的。它提供了如零拷贝、缓冲区池化等高级特性，这些特性都为 Netty 的高性能提供了保障。
• 灵活的管道处理（Pipeline）：Netty 的 Channel 支持管道处理机制，允许将多个 ChannelHandler 链接起来处理入站和出站事件。这种灵活性使得编写复杂的网络应用程序变得更加简单。
• 更好的错误处理和资源管理：Netty 的 Channel 实现了更精细的错误处理和资源管理机制。例如，它支持自动资源释放和异常通知机制，以确保资源的有效管理和稳定运行。

什么是 Netty 的零拷贝？

在传统的数据传输过程中，数据经常需要在用户空间和内核空间之间，或者在不同的缓冲区之间进行多次复制，这些复制操作消耗大量的CPU资源和时间。零拷贝技术的目的是减少这些复制步骤，从而提高数据处理的效率。

Netty 中的零拷贝减少了在数据处理过程中的内存复制操作，提高了 Netty 的性能。以下是 Netty 实现零拷贝的几种方式：

• CompositeByteBuf

CompositeByteBuf 是一种特殊的 ByteBuf，它可以将多个 ByteBuf 实例组合成一个单一的逻辑缓冲区，而无需在这些实例之间复制数据。这对于将多个小数据块组合成一个大的数据包以进行网络传输非常有用。

• FileRegion

对于文件传输，Netty 提供了 FileRegion 接口，它允许直接从文件系统缓存传输数据到网络，避免了将文件内容从内核空间复制到用户空间，再从用户空间复制到内核空间的网络缓冲区的过程。

• Slice()** 和 **Duplicate()

ByteBuf 提供了 slice() 和 duplicate() 方法，允许创建现有缓冲区的视图，而无需复制实际的数据。这些方法创建的新 ByteBuf 实例与原始实例共享相同的数据存储，但拥有独立的索引和标记。

• 内存映射文件（Memory-Mapped Files）

对于处理大文件，Netty 可以利用内存映射文件技术，这允许直接在内存中访问文件内容，减少了数据在用户空间和内核空间之间的来回复制。

Netty 发送消息有几种方式？

Netty 提供了多种方式来发送消息，如下：

• 直接写入 Channel

这是最直接的方式，直接调用Channel 的 write() 将消息写入 Channel。如果要立即将消息发送出去，可以调用 writeAndFlush() 方法，这将消息写入 Channel 并刷新缓冲区，使消息立即发送。

• 通过 ChannelPipeline 发送

通过 Channel 关联的 ChannelPipeline 发送。使用这种方式，消息会流经 Pipeline 中的各个 ChannelHandler。

• 写入到一个特定的 ChannelPromise

Netty 允许将消息写入 Channel，并与一个 ChannelPromise 相关联。这样做的好处是可以在消息被实际发送或操作完成时得到通知。这对于实现某些异步逻辑非常有用。

• 群发消息

对于需要将同一消息发送给多个 Channel 的情况，可以使用 ChannelGroup。通过 ChannelGroup，可以轻松地将消息群发给组内的所有 Channel。

默认情况 Netty 起多少线程？何时启动？

在默认情况下，Netty 的线程数量取决于它使用的 EventLoopGroup 类型和构造时的配置。对于最常用的 NioEventLoopGroup，如果没有指定线程数量，Netty 通常会创建的线程数等于机器的 CPU 核心数的两倍。

Netty 的线程通常在以下情况启动：

• 启动服务器或客户端时

创建并初始化一个 ServerBootstrap 或 Bootstrap 实例，然后调用其 bind() 或 connect() 方法时，Netty 会启动其线程。这通常发生在应用程序启动阶段，当你准备好接受连接或连接到远程服务器时。

• 懒加载启动

在某些情况下，Netty 可能会采用懒加载策略来启动其线程，意味着直到实际需要处理事件时，线程才会被启动。这有助于节省资源，特别是在初始化阶段不需要立即处理网络事件的应用中。

• EventLoopGroup 创建时

通常，当创建一个 EventLoopGroup 实例时，其关联的线程就会启动。例如，在创建 NioEventLoopGroup 时，它的线程会随之启动，准备好处理 I/O 事件。

Netty是如何解决JDK中的Selector 空轮训 BUG的？

Netty 为了解决 Selector 空轮训 bug，采取了以下措施：

1. 检测空轮询：Netty 的事件循环会持续追踪空轮询的次数。如果 Selector 在一定时间内连续多次返回空的就绪集合，Netty 会怀疑是遇到了空轮询的问题。
2. 重建 Selector：一旦确定发生了空轮询，Netty 会采取措施重建 Selector。这意味着它会创建一个新的 Selector 实例，并将原先的通道注册到这个新的 Selector 上。
3. 保留旧 Selector 的状态：在重建过程中，Netty 会尝试保持旧 Selector 的状态，确保在新的 Selector 上重新注册通道时，不会丢失任何关键的信息或状态。
4. 防止频繁重建：Netty 还会确保不会因为频繁检测到空轮询而过度重建 Selector。它通过设置阈值和时间间隔来避免这种情况，只在真正必要时才重建 Selector。

这种策略的关键在于准确检测到空轮询的发生，并在必要时迅速采取行动。通过这种方式，Netty 能够有效地规遍 JDK NIO 库中的这个已知问题，从而保证其网络应用的稳定性和性能。

**什么是 TCP 粘包/拆包?**怎么解决？

什么是TCP粘包/拆包问题？

1. TCP是面向流的协议：TCP协议发送的数据是基于字节流的，没有固定的边界。
2. 粘包：当发送方快速连续地发送多个数据包时，TCP可能会将它们合并为一个大的数据包进行发送。这意味着，接收方可能一次性接收到多个数据包的合并数据。
3. 拆包：相对地，TCP也可能将一个较大的数据包拆分成多个小的数据包发送。接收方需要多次读取才能获取完整的数据。

这两个现象可能导致数据的解析变得复杂，因为接收方可能无法直接确定一个数据包的开始和结束。

解决方法

1. 固定长度：设定每个数据包的固定长度。如果数据不足，可以用空白数据填充。
2. 分隔符：在每个数据包的末尾添加特定的分隔符来标记数据包的结束。
3. 长度字段：在数据包的开始部分添加长度字段，用以表示数据包的长度。
4. 应用层协议：设计一个简单的应用层协议，规定数据的发送和接收格式。
5. 使用现有协议框架：比如 Netty，提供了针对粘包/拆包问题的解决方案，如 LineBasedFrameDecoder、DelimiterBasedFrameDecoder、LengthFieldBasedFrameDecoder 等。

如何在 Netty 中解决 TCP 粘包问题？

Netty 提供了一系列的内置解码器，可以帮助处理基于不同规则的数据流分割，从而有效地解决粘包/拆包问题。以下是一些常用的解码器：

1. LineBasedFrameDecoder：这个解码器用于处理以行为单位的文本流。它按行分割数据流，依赖于行结束符（如 \n 或 \r\n）来标识消息的结束。
2. DelimiterBasedFrameDecoder：此解码器允许你指定一个或多个自定义的分隔符。当任何一个分隔符被检测到时，数据被分割成帧。
3. LengthFieldBasedFrameDecoder：这可能是处理粘包/拆包最灵活的解码器。它使用消息中的一个字段来表示消息的长度，允许你指定长度字段的位置和大小。
4. FixedLengthFrameDecoder：当所有消息都有固定的长度时，这个解码器非常有用。它根据指定的长度来分割传入的数据流。

为什么需要心跳机制？Netty 中心跳机制了解么？

心跳主要用于维持客户端与服务器之间的连接状态，以及确保网络的稳定性和可靠性，它在许多网络通信系统中都非常关键。下面是心跳机制的主要用途：

1. 维持连接活性：在长时间无数据交换的连接中，心跳消息确保连接依然活跃，防止被网络设备（如路由器、防火墙）误认为已经断开。
2. 检测故障：心跳可以用来检测网络故障或不可达的对端。如果在特定时间内未收到心跳回应，可以认为对端或网络出现了问题。
3. 节省资源：通过定期的心跳检测，可以及时发现并关闭失效的连接，从而节省服务器资源。
4. 同步状态：某些应用使用心跳来同步或更新状态信息，确保双方的数据一致性。

Netty 的心跳检测

Netty 提供了心跳机制的实现，主要是通过以下两种 Handler 实现的：

1. IdleStateHandler：这个 Handler 用于检测读/写空闲时间。如果在配置的空闲时间内没有读或写操作发生，它会触发一个 IdleStateEvent 事件。
2. ChannelInboundHandlerAdapter / ChannelDuplexHandler：通过实现自定义的 Handler 并重写 userEventTriggered 方法，可以对 IdleStateEvent 事件进行处理。通常在此处实现心跳消息的发送。

Netty 支持哪些心跳类型设置？

Netty 常见的心跳类型有如下几种：

• 空闲检测（IdleStateHandler）：这是Netty中最常用的心跳类型。它允许你检测读、写或读写操作的空闲时间。如果在指定的时间间隔内没有发生相应的操作，Netty会触发一个IdleStateEvent事件。
• 心跳消息（心跳帧）：这种类型的心跳通过定期发送特定的消息（如心跳帧）来维护连接。如果一段时间内没有数据交换，应用程序可以发送一个轻量级的心跳消息来确认连接仍然是活跃的。
• Keepalive：这是TCP层面的一种机制，用于检测死链接。Netty可以配置使用TCP的Keepalive功能，尽管这不是Netty特有的，而是底层操作系统支持的特性。
• 自定义心跳机制：Netty提供了强大的扩展性，允许开发者根据需求实现自定义的心跳机制。这通常涉及定时任务、定制协议消息等。

对于大多数场景，我们使用空闲检测就可以了。

Netty不是真正的“异步IO”，你认同吗？

Netty 被广泛认为是实现了“异步IO”的框架，但这个说法有时会引起一些误解，尤其是当涉及到“真正的异步IO”这个概念时。这主要是因为对“异步IO”的定义和实现方式的理解不同。

1. 异步IO的定义：传统意义上的异步IO指的是应用程序发起IO请求后，可以立即返回，不需要等待IO操作的完成。IO操作的完成状态和数据通过回调、事件、或者其他机制通知给应用程序。
2. Netty的实现：Netty 使用了Java NIO（非阻塞IO）作为其核心，支持事件驱动和回调机制。这意味着Netty可以在无需阻塞线程的情况下处理IO请求，这是异步IO的一个重要特征。Netty的设计允许用户编写代码，这些代码在IO操作完成时被回调，而不是在IO操作上阻塞。
3. 对比传统阻塞IO：在传统的阻塞IO模型中，应用程序在发起IO请求后，必须等待IO操作完成才能继续执行，这在高并发场景下是一个大问题。Netty通过非阻塞和异步的方式，解决了这个问题。
4. 异步IO与“真正的异步IO”：有些人认为“真正的异步IO”指的是完全由操作系统内核处理IO操作，而应用程序完全不需要关心IO操作的处理过程，如Linux的IO多路复用机制（epoll）和Windows的IOCP。从这个角度看，Netty不是“真正的异步IO”，因为它仍然依赖于在用户空间的线程来处理某些IO操作。

总结来说，Netty实现了异步和非阻塞的IO模型，与传统的阻塞IO模型相比，它提供了更高的性能和更好的可扩展性。但如果将“真正的异步IO”定义为完全由操作系统内核处理所有IO操作，那么Netty并不完全符合这个定义。然而，这并不减少Netty在实现高性能网络应用方面的价值。

Netty主要采用了哪种设计模式？简要介绍下！

Netty 在其设计中采用了多种设计模式，主要包括：

1. 单例模式：在Netty中用于创建一些全局唯一的对象，如ResourceLeakDetector。
2. 工厂模式：在Netty中，例如Bootstrap和ChannelFactory使用了工厂模式来创建Channel实例。
3. 策略模式：用于封装一系列的算法或策略，允许在运行时选择使用哪种策略。例如，Netty中的SslContext选择不同的SSL/TLS实现。
4. 装饰器模式：在ChannelHandler的实现中广泛使用，例如添加日志、编码/解码等功能的handler实际上是对ChannelHandler的装饰。
5. 建造者模式：例如，Bootstrap和ServerBootstrap类使用建造者模式来简化复杂对象的创建过程。
6. 适配器模式（Adapter）：Netty中的ChannelHandlerAdapter和ChannelInboundHandlerAdapter是适配器模式的例子。它们为用户提供了将自己的代码适配到Netty框架中的方法。
7. 责任链模式（Chain of Responsibility）：Netty的ChannelPipeline实现了这一模式，其中每个ChannelHandler都可以视为链中的一个节点，负责处理入站和出站的IO事件，然后将事件传递到链上的下一个处理器。
8. 观察者模式（Observer）：这在Netty的Future和Promise中有体现。这些类允许用户在操作完成时得到通知，并能在操作完成后执行回调。
9. 命令模式（Command）：在Netty中，所有出站操作都可以看作是对Channel的命令。这些命令通过ChannelPipeline发送，并由相应的ChannelHandler处理。

说说Netty中的责任链设计模式

在 Netty 中，责任链模式主要体现在 ChannelPipeline 的设计和使用上。

ChannelPipeline 是一个包含多个 ChannelHandler 的列表，这些 ChannelHandler 以一定的顺序处理或拦截入站（Inbound）和出站（Outbound）操作。每个 ChannelHandler 可以视为责任链上的一个节点。当网络事件发生时，事件会沿着 ChannelPipeline 中的 ChannelHandler 链进行传递。