Netty

李温候

已于 2024-01-21 07:58:17 修改

阅读量879

点赞数 19

文章标签： java 后端

于 2024-01-20 13:42:31 首次发布

本文链接：https://blog.csdn.net/weixin_64838846/article/details/135714300

版权

笔者的Netty是跟着黑马的满老师学的，满老师直接封神！满老师和周阳老师是我心目中讲课最好的老师。Netty在网络编程中还是很重要的，也出现了以前从没有见过的名词，我都在笔记都记录了。满老师IDEA玩的贼溜，有很多使用IDEA的技巧，对看源码的帮助很大，跟着满老师学习一件很享受的事，有时间的话Netty源码部分值得我在刷一遍。

文章目录

NIO

socket是什么

Socket 是一种在计算机网络中进行通信的一种方式。它是一种抽象的概念，通常用于描述应用程序之间的网络通信的接口。
通过 Socket，应用程序可以在网络上发送和接收数据。它提供了一种编程接口，使得应用程序能够创建、连接、发送和接收数据等操作。Socket 可以在不同的计算机之间建立通信连接，可以在同一台计算机的不同进程之间建立通信连接。
Socket 提供了一种灵活、可靠的通信机制，它可以在不同的网络协议中使用，如 TCP (Transmission Control Protocol) 和 UDP (User Datagram Protocol)。TCP 提供了可靠的、面向连接的通信，而 UDP 则提供了无连接的、不可靠的通信。
在网络编程中，开发人员可以使用各种编程语言的 Socket API 来创建和操作 Socket。这些 API 提供了一组函数和方法，用于创建 Socket、建立连接、发送和接收数据等操作。
总结起来，Socket 是一种用于实现网络通信的编程接口，它提供了一种通用的、可靠的方式，使得应用程序能够在计算机网络上进行数据传输和通信。

鼠标放在方法上，可以查看方法相关信息

直接内存和堆内存有什么区别

直接内存（Direct Memory）和堆内存（Heap Memory）是在计算机编程和计算机系统设计中经常提到的两种内存概念，它们有以下几点区别：

分配方式：
- 直接内存： 直接内存通常是通过操作系统的系统调用或者特定的 API 分配的，它不受 Java 堆大小的限制。在 Java 中，直接内存通常是通过 ByteBuffer 类来操作的。
- 堆内存： 堆内存是由 Java 虚拟机动态分配和管理的内存区域，其中存放了所有通过 new 关键字创建的对象实例。
生命周期：
- 直接内存： 直接内存的生命周期通常与相应的对象（如 ByteBuffer）相关联。当对象被垃圾回收时，相应的直接内存也会被释放。
- 堆内存： 堆内存中的对象的生命周期由 Java 虚拟机的垃圾回收器管理。当对象不再被引用时，垃圾回收器会将其标记为可回收，并在适当的时机进行回收。
访问方式：
- 直接内存： 直接内存可以通过 Java 的 NIO（New I/O）库来进行高效的数据操作，通常用于 I/O 操作和与本地代码进行交互。
- 堆内存： 堆内存中的对象可以直接通过引用进行访问和操作，通常用于存储大量的对象实例。
性能和用途：
- 直接内存： 直接内存的操作通常比堆内存更高效，特别是在进行大量的 I/O 操作时。它通常用于需要和本地库进行交互的情况。
- 堆内存： 堆内存适合存储大量的动态对象，并且受到 Java 虚拟机的自动内存管理的支持。
  总的来说，直接内存和堆内存在分配方式、生命周期、访问方式、性能和用途等方面有所不同，开发人员应根据具体的需求和场景选择合适的内存类型。

黏包，半包

在网络通信中，“黏包”（Packet Concatenation）和"半包"（Half Packet）是两种常见的问题，涉及到数据的传输和接收。

黏包（Packet Concatenation）：
- 定义： 黏包是指发送方在传输数据时，多个数据包被连续发送到接收方，形成一个大的数据块，接收方在接收时无法正确区分各个数据包。
- 原因： 这可能是由于发送方在发送数据包时，并没有在数据包之间插入足够的分隔符或长度信息，导致接收方难以准确地分割数据。
- 解决方法： 在数据包中加入长度信息或者特定的分隔符，以便接收方能够正确地解析和分离各个数据包。
半包（Half Packet）：
- 定义： 半包是指接收方在接收数据时，只收到了一个完整数据包的一部分，而不是完整的数据包。这可能导致接收方无法正确解析数据。
- 原因： 这通常发生在数据包的长度信息传输不完整或者传输过程中被拆分成多个部分，导致接收方无法准确知道完整数据包的长度。
- 解决方法： 在数据包中加入长度信息，确保接收方能够正确获取到每个数据包的完整长度，从而正确解析数据。
  解决黏包和半包的问题通常需要在通信协议中引入一些机制，比如在数据包中添加长度字段，或者使用特定的分隔符来标识数据包的边界。这样接收方就能够准确地判断数据包的边界，避免黏包和半包的问题。在实际的网络编程中，开发者需要注意处理这些问题，以确保数据的正确传输和解析。

e.printStackTrace()

e.printStackTrace() 是一个 Java 中用于打印异常堆栈信息的方法。当程序执行过程中抛出异常时，可以使用这个方法将异常的详细信息输出到控制台，以便开发人员调试和定位问题。

具体而言，e.printStackTrace() 会打印异常的类型、消息以及异常发生的堆栈轨迹（即异常发生时的调用栈信息）。这对于追踪问题、找出异常发生的原因以及定位代码中可能存在的错误非常有帮助。

Ctrl + O 调出重写方法框

CTRL+ALT+T try-catch

IDEA DEbug模式下运行代码

条件触发和水平触发

条件触发和水平触发是两种不同的触发方式，它们通常与计算机编程、事件处理或系统设计相关。

条件触发（Conditional Trigger）： 条件触发是指在特定条件满足时触发某个事件或行为。这种触发方式通常涉及到对条件的检查，只有当条件为真时，相应的事件或动作才会被触发执行。条件触发常见于编程语言中的条件语句，例如在一个 if 语句中触发某段代码。
水平触发（Horizontal Trigger）： 水平触发通常与数据库或系统中的事件触发器相关。水平触发是指在数据表的某一行发生变化时触发相应的操作。这种触发方式不依赖于特定的条件，而是依赖于数据的变化。例如，当数据库中的某一行数据被更新时，可以触发相应的触发器来执行一些操作。
总体而言，条件触发强调在特定条件下执行某个操作，而水平触发强调在数据变化时执行相应的操作。这两种触发方式在不同的上下文和应用中都有各自的用途。

SelectionKey的作用是什么

SelectionKey 是 Java NIO（New I/O）中的一个关键类，用于表示在非阻塞 I/O 操作中**通道（Channel）和选择器（Selector）**之间的注册关系。它主要用于以下几个方面：

通道和选择器的注册关系： SelectionKey 维护了一个通道与选择器的注册关系。当一个通道向选择器注册时，会创建一个对应的 SelectionKey 对象，该对象包含了关联的通道、选择器、感兴趣的操作集（例如读、写、连接、接受）等信息。
事件的处理： SelectionKey 用于表示通道上发生的特定事件，如可读、可写、连接就绪、接受就绪等。通过检查 SelectionKey 的标志位，可以确定通道上发生了哪些事件。
取消注册： 如果通道不再对某个事件感兴趣，或者通道关闭时，可以使用 SelectionKey 的 cancel 方法取消注册，从而告诉选择器不再关注该通道的事件。
附加对象（Attachment）： SelectionKey 允许关联一个附加对象，这个对象可以是任意用户定义的对象。通过 attach 和 attachment 方法，可以将一个对象关联到 SelectionKey 上，以便在处理事件时获取和使用附加对象。
在使用 Java NIO 进行非阻塞 I/O 编程时，SelectionKey 是非常重要的，它允许程序通过一个选择器同时管理多个通道，从而提高系统的性能和效率。

ServerSocketChannel和SocketChannel的作用

ServerSocketChannel 和 SocketChannel 是 Java NIO（New I/O）中用于网络通信的两个重要类，它们分别用于处理服务器端和客户端的通信。

ServerSocketChannel（服务器套接字通道）：
- 作用： ServerSocketChannel 主要用于在服务器端监听传入的连接请求。当有客户端尝试连接到服务器时，服务器的 ServerSocketChannel 将接受连接并创建一个新的 SocketChannel 用于与客户端进行通信。
- 使用步骤： 服务器端通常会按照以下步骤使用 ServerSocketChannel：
  - 创建 ServerSocketChannel 实例。
  - 绑定到特定的服务器地址和端口。
  - 调用 accept() 方法接受客户端连接请求，返回一个新的 SocketChannel 用于与客户端通信。
  - 在返回的 SocketChannel 上进行读写操作。
SocketChannel（套接字通道）：
- 作用： SocketChannel 用于在客户端和服务器之间建立通信连接。它允许客户端与服务器进行数据的读写操作。
- 使用步骤： 客户端通常会按照以下步骤使用 SocketChannel：
  - 创建 SocketChannel 实例。
  - 连接到服务器的地址和端口。
  - 在连接成功后，可以通过 SocketChannel 进行数据的读写操作。

通过结合使用 ServerSocketChannel 和 SocketChannel，可以构建基于非阻塞 I/O 的网络应用程序。ServerSocketChannel 负责接受连接请求，而每个接受的连接都将创建一个新的 SocketChannel，用于实际的数据传输。这种模型允许服务器同时处理多个连接，提高了系统的并发性能。

volatile的作用

volatile 是 Java 中的关键字，用于修饰变量。它的主要作用是确保多线程环境下对该变量的可见性和禁止指令重排序。以下是 volatile 的主要作用：

可见性： 当一个变量被声明为 volatile 时，线程在读取该变量的值时会直接从主内存中读取，而不是从线程的本地缓存中读取。这确保了当一个线程修改了该变量的值时，其他线程能够立即看到修改后的值。在没有 volatile 修饰的情况下，一个线程修改了变量的值，其他线程可能无法立即看到这个修改，因为它们在各自的本地缓存中保存了变量的副本。
禁止指令重排序： volatile 还禁止了指令的重排序优化。在多线程环境下，为了提高执行效率，编译器和处理器可能会对指令进行重排序。使用 volatile 可以防止在代码执行时对 volatile 变量相关的指令进行重排序，从而确保线程按照预期的顺序执行。
需要注意的是，volatile 保证了可见性和禁止指令重排序，但并不保证原子性。如果一个操作涉及到了多步骤，且需要保证原子性，可能需要使用其他机制，比如 synchronized 关键字或者 java.util.concurrent 包中提供的原子类。

Selector是什么

Selector 是 Java NIO（New I/O）中的一个关键类，用于实现非阻塞 I/O 操作。它允许一个线程同时监控多个通道（例如 SocketChannel 或 ServerSocketChannel）的状态，只有当其中某个通道处于就绪状态时才进行 I/O 操作，从而提高了系统的效率和性能。
主要作用包括：

多通道管理： Selector 可以通过**一个线程监控多个通道的状态。**这意味着一个单独的线程可以处理多个通道的 I/O 操作，避免了创建大量线程来处理每个通道的阻塞 I/O。
非阻塞 I/O： Selector 实现了非阻塞 I/O 模型。通过 Selector，可以使用单个线程同时管理多个通道，只有当某个通道的状态发生变化（如可读、可写等）时，才会触发相应的 I/O 操作，而不需要线程一直阻塞等待某个通道准备就绪。
注册通道： 通过 Selector 的 register 方法，可以将通道注册到选择器上，告诉选择器要监控该通道的什么事件。可以监控的事件包括读就绪、写就绪、连接就绪、接受就绪等。
选择操作： 通过 Selector 的 select 方法，可以查询选择器中所有注册的通道，找出哪些通道已经准备就绪。这个方法会阻塞直到至少有一个通道准备就绪，或者超时。
Selector 类在 Java NIO 编程中是非常重要的，特别适用于需要处理多个通道的情况，例如服务器端需要同时处理多个客户端连接的场景。通过 Selector，可以使用较少的线程来管理多个通道，提高了系统的并发处理能力和效率。

想抽取一个线程的代码到另一个线程运行，我们可以用队列来实现

socket缓区的作用

Socket缓冲区是在网络通信中用于临时存储数据的一种机制，它位于操作系统内核空间中，用于暂时存储待发送或接收的数据。Socket缓冲区的作用包括以下几个方面：

提高效率： Socket缓冲区的存在可以减少每次发送或接收数据时与内核的频繁交互。通过将数据暂时存储在缓冲区中，可以减少系统调用的次数，提高数据传输的效率。
缓解阻塞： 在Socket通信中，发送方和接收方的数据传输速度可能不一致，或者网络延迟导致某一方无法立即处理数据。Socket缓冲区可以暂时存储未处理的数据，使得发送方和接收方可以在适当的时机进行数据的发送和接收，从而缓解阻塞情况。
流量控制： Socket缓冲区还可以用于流量控制，防止发送方过快地向接收方发送数据，从而导致接收方无法及时处理。通过控制缓冲区的大小，可以调整发送方的发送速率，以适应接收方的处理能力。
临时存储： 当数据被发送或接收时，先存储在Socket缓冲区中，等待合适的时机再进行实际的传输或处理。这种机制允许发送方一次性发送多个小数据包，或者接收方一次性接收多个小数据包，从而提高通信的效率。
总的来说，Socket缓冲区在Socket通信中起到了缓存和调节数据流的作用，有助于优化数据传输的效率和稳定性。

Netty入门

NIO和BIO

NIO（New I/O）和BIO（Blocking I/O）都是Java中用于处理I/O操作的不同方式。

BIO（Blocking I/O）：
- 阻塞模式： 在BIO中，I/O操作是阻塞的，即当一个线程执行读或写操作时，如果没有数据可读或无法写入，线程会被阻塞，直到有数据可用或可以写入。
- 同步： 每个I/O操作都是同步的，线程在进行I/O操作时会等待其完成，这可能会导致线程的资源浪费，因为线程可能在等待中什么都不做。
NIO（New I/O）：
- 非阻塞模式： NIO引入了非阻塞I/O操作的概念。在NIO中，一个线程可以同时处理多个通道的数据。当一个通道的数据没有准备好时，线程不会被阻塞，而是可以继续处理其他通道。
- 选择器（Selector）： NIO中引入了Selector，允许一个线程同时管理多个通道。通过选择器，可以实现在一个线程中处理多个I/O操作，提高了系统的并发性能。
- Buffer和Channel： NIO使用Buffer来处理数据，而不是直接使用流。数据从Channel读取到Buffer，或者从Buffer写入到Channel，使得数据操作更灵活和高效。
  总的来说，BIO是传统的阻塞I/O模型，而NIO是基于非阻塞I/O的新模型，引入了更灵活的缓冲区和通道概念，以提高I/O操作的效率和并发处理能力。在高并发的网络应用中，NIO通常比BIO更适用。

Netty流程

All表示debug是会阻塞全部线程 Thread表示只会阻塞当前线程

在主线程里面开启一个线程

handler执行中换人

异步处理结果

函数式接口

指只包含一个抽象方法的接口。在Java中，可以使用@FunctionalInterface注解来明确一个接口是函数式接口。函数式接口的存在主要是为了支持Lambda表达式，使得可以将函数作为参数传递给方法，或者用Lambda表达式来实例化函数式接口。

@FunctionalInterface
interface MyFunctionalInterface {
void myMethod(); // 这是唯一的抽象方法
}

Thread 里面的run方法也是一个唯一的抽象方法

Netty进阶

RPC

RPC（Remote Procedure Call）是远程过程调用的缩写，是一种计算机通信协议。它允许程序在网络上请求服务而不需要了解底层网络细节。在RPC中，客户端调用远程服务器上的过程（或方法），就像调用本地过程一样，而不必担心网络通信的具体实现。
RPC的基本思想是让程序调用远程服务的过程看起来和调用本地服务的过程一样。通过使用RPC，开发者可以将网络通信的复杂性隐藏在底层，从而使分布式系统的开发更加方便。
通常，RPC包括以下几个关键组件：

客户端（Client）： 发起RPC调用的程序或模块。
服务端（Server）： 提供RPC服务的程序或模块。
Stub（存根）： 客户端和服务端分别有本地的Stub，用于封装调用和响应的信息，使得调用方感觉就像调用的是本地过程一样。
序列化（Serialization）： 将数据在网络上传输前序列化为字节流的过程，以及在接收端将字节流反序列化为数据的过程。
常见的RPC框架包括gRPC、Apache Thrift、JSON-RPC等，它们提供了方便的工具和协议，使得开发者可以更容易地实现分布式系统。

###### 选择是否开启池化

GC回收

在Java中，GC（Garbage Collection）回收指的是自动管理和释放不再被程序使用的内存空间的过程。Java是一种高级语言，其内存管理是由Java虚拟机（JVM）负责的。GC的主要目标是检测和回收不再使用的对象，以释放内存并防止内存泄漏。
在Java中，程序员不需要手动分配或释放内存，因为Java的垃圾回收器负责管理这些任务。垃圾回收器会定期检查程序运行时创建的对象，标记那些不再被引用的对象，并将其内存释放回堆内存池，以便重新使用。这样，开发者就不必担心手动释放不再需要的内存，从而减少了内存管理的复杂性和错误的可能性。
Java中有不同的垃圾回收算法和垃圾回收器，每个都有其优点和适用场景。一些常见的垃圾回收器包括Serial收集器、Parallel收集器、CMS（Concurrent Mark-Sweep）收集器和G1（Garbage-First）收集器。这些垃圾回收器在不同的应用场景中提供了不同的性能特点，以满足各种应用程序的需求。

TCP，UDP

TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是两种常见的传输层协议，用于在计算机网络上进行数据通信。以下是它们的一些主要区别：

连接性：
- TCP： 提供面向连接的通信，确保数据的可靠传输。在通信开始之前，TCP使用三次握手建立连接，然后在通信结束时使用四次挥手关闭连接。
- UDP： 无连接的协议，不保证数据的可靠性。每个数据包都是独立的，没有建立连接的阶段和关闭连接的阶段。
可靠性：
- TCP： 提供可靠的数据传输，通过序列号、确认和重传机制来确保数据的完整性和有序性。
- UDP： 不保证可靠性，数据包可能会丢失或以不同的顺序到达。
速度：
- TCP： 由于提供了可靠性，因此可能会有一些额外的开销，导致相对较慢的传输速度。
- UDP： 由于不保证可靠性，因此通常具有较低的延迟和更快的传输速度。
应用场景：
- TCP： 适用于要求可靠传输的应用，如文件传输、网页访问、电子邮件等。
- UDP： 适用于对实时性要求较高的应用，如音频、视频流、在线游戏等。
头部开销：
- TCP： 有较大的头部开销，包含序列号、确认号等信息。
- UDP： 头部较小，开销相对较小。
  总的来说，选择使用TCP还是UDP取决于应用的具体要求。如果需要可靠性和有序性，通常选择TCP。如果对实时性要求较高，而且可以容忍一些数据丢失，则可以选择UDP。

IDEA使用小技巧

Ctrl + Alt + M 抽取代码块

Ctrl + Alt + P 抽取代码成为方法参数

Ctrl + Alt + V 抽取代码成一个变量

IDEA重构小技巧

把类抽取成内部类

把内部类转换成普通的类

Netty启动关键代码

这两行代码涉及到使用Netty框架创建一个简单的服务器并启动它。以下是对这两行代码的解析：

服务器绑定（Bind）和同步（Sync）：
```
ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
```
- serverBootstrap 是一个 Netty 的 ServerBootstrap 实例，用于配置和启动服务器。
- bind(8080) 表示绑定服务器监听的端口号为 8080。
- sync() 是一个同步方法，它会阻塞当前线程直到绑定操作完成。返回的 ChannelFuture 对象用于异步地获得绑定的结果或执行后续的操作。
关闭服务器和同步：
```
channelFuture.channel().closeFuture().sync();
```
- channelFuture.channel() 返回与当前绑定的服务器通道（Channel）相关联的 Channel 对象。
- closeFuture() 返回一个 ChannelFuture 对象，表示当与当前通道关联的通道关闭时将触发的事件。
- sync() 同样是一个同步方法，它会阻塞当前线程直到关闭操作完成。
  这两行代码的目的是启动服务器，并在服务器关闭时等待其完成。在 Netty 中，通常会使用异步的方式处理事件，例如处理连接、数据读取等，但是在这里使用了 sync() 方法，使得当前线程在绑定和关闭操作上同步等待，以确保在这些操作完成之前不继续执行后续的代码。需要注意的是，在实际的生产代码中，可能需要添加异常处理逻辑，处理可能发生的异常情况。例如，可以通过在 sync() 方法调用前后添加 try-catch 块来捕获并处理可能的异常。

Codec

表示包含decoder 和 encoder

new LoggingHandler()

ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));

获取通道的ChannelPipeline，它是一个处理通道数据流的处理器链。
向ChannelPipeline中添加了一个新的处理器LoggingHandler，并设置其日志级别为DEBUG。LoggingHandler用于在控制台上打印有关通道事件和数据的日志信息。

序列化是什么意思

序列化是将对象转换为字节序列的过程，以便在网络上传输或将其保存到持久存储介质（如磁盘）中。反之，从字节序列中恢复对象的过程称为反序列化。
在软件开发中，序列化通常涉及到将对象的状态转换为一系列字节，以便能够在不同系统、不同编程语言之间进行数据交换或持久化存储。这对于分布式系统、远程调用、缓存和数据存储等方面都是很常见的需求。
一些常见的序列化格式包括 JSON、XML、Protocol Buffers（protobuf）、Thrift 等。不同的序列化格式有各自的优点和适用场景。选择合适的序列化格式通常取决于应用程序的需求，例如性能、可读性、数据体积等方面的考虑。
在Java中，对象的序列化和反序列化通常使用ObjectOutputStream和ObjectInputStream来实现。在其他编程语言中，也有类似的序列化和反序列化机制。

###### 常见进制前缀

二进制（Binary）:
- 二进制使用前缀**0b或0B**表示，例如：int binary = 0b101010;
八进制（Octal）:
- 八进制使**用前缀0**表示，例如：int octal = 052;
十六进制（Hexadecimal）:
- 十六进制使用前缀**0x或0X表**示，例如：int hex = 0x2A;

EmbeddedChannel类

EmbeddedChannel是Netty中提供的一个用于测试的特殊通道类。它允许您在测试中模拟通道的行为，而无需实际进行网络通信。主要用于单元测试和集成测试，以验证处理器链（pipeline）的正确性。
以下是EmbeddedChannel的一些主要作用和特点：

模拟通道行为：
- EmbeddedChannel允许您将处理器链部署到一个虚拟的通道中，然后通过发送数据模拟通信事件，触发处理器链中的各个处理器进行处理。
同步测试：
- 在测试中，您可以同步地触发事件，然后检查处理器链的状态和输出，以确保每个处理器按照预期执行。
验证处理器逻辑：
- 使用EmbeddedChannel，您可以轻松地测试自定义处理器的逻辑，确保它们正确地处理输入和生成预期的输出。
方便的断言方法：
- EmbeddedChannel提供了一些方便的断言方法，例如readInbound()和readOutbound()，用于检查输入和输出是否符合预期。
无需实际网络连接：
- 由于EmbeddedChannel是在内存中模拟的通道，因此测试不需要实际的网络连接。这使得测试更加可控和可靠。
  示例使用EmbeddedChannel的测试代码可能如下所示：

// 创建一个EmbeddedChannel，并将处理器链部署到通道中
EmbeddedChannel channel = new EmbeddedChannel(new MyHandler());
// 发送数据模拟通信事件
channel.writeInbound(data);
<br>
<br>

@Sharable

@Sharable是Netty框架中的一个注解，用于标识一个ChannelHandler是否可以在多个ChannelPipeline之间共享使用。

在Netty中，每个ChannelPipeline都有自己的ChannelHandler实例，以确保线程安全。然而，有些处理器是无状态的，可以在多个ChannelPipeline之间共享，而不会导致不良的影响。为了标识这种情况，可以使用@Sharable注解。

使用@Sharable注解的处理器必须满足以下条件：

无状态： 被标记为@Sharable的处理器应该是无状态的，不依赖于特定的Channel实例状态或上下文。因为它可能在多个ChannelPipeline中共享使用，保持无状态可以确保在不同上下文中使用时不会引发问题。
线程安全： 被标记为@Sharable的处理器应该是线程安全的，因为它可能在多个线程中同时被调用。如果处理器有状态，则需要确保在处理器内部采取适当的同步措施。

SimpleChannelInboundHandler

在Netty框架中，SimpleChannelInboundHandler是ChannelInboundHandler接口的一个实现类，专门用于处理入站数据。它提供了更简化的消息处理机制，使得开发者可以更方便地处理特定类型的消息，并且在处理完成后，Netty会自动释放相关资源。
SimpleChannelInboundHandler的主要特点包括：

自动释放资源： 与普通的ChannelInboundHandler不同，SimpleChannelInboundHandler在处理消息后会自动释放消息的相关资源。这一点对于避免内存泄漏非常有帮助。
泛型支持： SimpleChannelInboundHandler是一个泛型类，允许您指定要处理的消息类型。当有新消息入站时，框架会检查消息类型是否匹配，只有匹配的消息类型才会被处理。
消息过滤： 可以方便地通过泛型指定要处理的消息类型，从而过滤出感兴趣的消息类型，不处理其他类型的消息。
适用于处理业务逻辑： 通常用于处理具体业务逻辑而不是处理底层的通信细节。例如，处理协议中的业务消息。
示例用法如下：

CountDownLatch类

CountDownLatch是Java中的一个并发工具类，用于在多线程环境中控制线程的执行顺序。它主要用于等待一组线程完成执行，然后再执行主线程或其他线程的任务。
CountDownLatch的作用可以总结为两个方面：

等待其他线程完成： 主线程或某个线程可以调用CountDownLatch.await()方法来等待计数器减到零，表示其他线程已经完成了任务。
减少计数： 其他线程执行完任务后，可以调用CountDownLatch.countDown()方法来减少计数器的值，表示一个任务已经完成。
使用步骤如下：

在主线程或等待线程中创建CountDownLatch对象，指定计数器的初始值。
将CountDownLatch对象传递给需要等待的线程。
在需要等待的线程中，在任务执行完毕后调用countDown()减少计数。
在主线程或等待线程中，调用await()等待计数器减到零。
示例代码如下：

import java.util.concurrent.CountDownLatch;
public class Example {
    public static void main(String[] args) throws InterruptedException {
        // 创建CountDownLatch，计数器初始值为3
        CountDownLatch latch = new CountDownLatch(3);
        // 创建三个线程，并传递CountDownLatch对象
        Thread worker1 = new Worker(latch, "Worker 1");
        Thread worker2 = new Worker(latch, "Worker 2");
        Thread worker3 = new Worker(latch, "Worker 3");
        // 启动线程
        worker1.start();
        worker2.start();
        worker3.start();
        // 主线程等待，直到计数器减到零
        latch.await();
        // 主线程继续执行
        System.out.println("All workers have finished their tasks.");
    }
    static class Worker extends Thread {
        private final CountDownLatch latch;
        public Worker(CountDownLatch latch, String name) {
            super(name);
            this.latch = latch;
        }
        @Override
        public void run() {
            // 模拟任务执行
            System.out.println(getName() + " is working.");
            
            // 任务完成后减少计数
            latch.countDown();
        }
    }
}

在这个例子中，主线程创建了一个CountDownLatch对象，初始计数器值为3。然后创建了三个线程（Worker 1、Worker 2、Worker 3），每个线程执行完任务后调用countDown()减少计数。主线程调用await()等待计数器减到零，表示所有任务都已完成。

AtomicBoolean类

AtomicBoolean是Java中java.util.concurrent.atomic包提供的一个原子布尔变量类。它提供了一种线程安全的方式来进行布尔变量的操作，避免了多线程环境下的竞态条件。
主要作用和特点包括：

原子性操作： AtomicBoolean提供了一系列原子性的操作，例如get、set、compareAndSet等，这些操作是不可分割的，从而保证了在多线程环境中对布尔变量的操作的原子性。
避免竞态条件： 在多线程环境中，普通的布尔变量在进行读取和写入操作时可能存在竞态条件，导致不确定的结果。使用AtomicBoolean可以避免这种问题，确保线程安全。
支持原子条件更新： 除了基本的原子性操作外，AtomicBoolean还支持条件更新，例如compareAndSet方法可以在满足特定条件时进行更新。
内存可见性： 与普通变量不同，通过AtomicBoolean进行的操作具有内存可见性，这意味着一个线程对变量的修改对其他线程是可见的。
示例用法如下：

import java.util.concurrent.atomic.AtomicBoolean;
public class Example {
    public static void main(String[] args) {
        // 创建AtomicBoolean对象，初始值为false
        AtomicBoolean atomicBoolean = new AtomicBoolean(false); 
        // 在多线程环境中进行原子性操作
        if (atomicBoolean.compareAndSet(false, true)) {
            System.out.println("Value is set to true.");
        } else {
            System.out.println("Value was not set to true.");
        }
    }
}

在这个例子中，通过AtomicBoolean创建了一个原子布尔变量，并使用compareAndSet方法进行原子性的条件更新。这可以在多线程环境中确保对布尔变量的操作是线程安全的。

Netty优化

valueof()

valueOf()是Java中的一个静态方法，它通常用于将字符串转换为枚举类型的常量。在Java中，枚举类型是一组有限的常量值，每个值都是枚举类型的一个枚举对象。valueOf()方法可以将字符串转换为枚举类型的枚举对象，如果字符串与枚举类型中的常量值不匹配，则会抛出IllegalArgumentException异常。
valueOf()方法的语法如下：

public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)

参数说明：

enumType：枚举类型的Class对象，指定要转换的枚举类型。
name：要转换的字符串，表示枚举类型中的常量值。字符串必须与枚举类型中定义的常量名称相同，否则会抛出IllegalArgumentException异常。
示例代码如下：

public enum DayOfWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}
public class Example {
    public static void main(String[] args) {
        // 将字符串转换为枚举对象
        DayOfWeek day1 = DayOfWeek.valueOf("MONDAY");
        System.out.println(day1); // 输出: MONDAY
        // 如果字符串不匹配，则抛出异常
        DayOfWeek day2 = DayOfWeek.valueOf("INVALID");
        // 抛出IllegalArgumentException异常: No enum constant DayOfWeek.INVALID
    }
}

在这个例子中，我们定义了一个枚举类型DayOfWeek，包含一周的每一天。然后，在Example类中，我们使用valueOf()方法将字符串转换为枚举对象。第一个例子将字符串"MONDAY"转换为DayOfWeek类型的枚举对象，输出结果为MONDAY。第二个例子将字符串"INVALID"转换为枚举对象，由于该字符串不匹配任何一个枚举常量，因此会抛出IllegalArgumentException异常。

ordinal()

ordinal()是Java中枚举类型（Enum）中的一个方法，它返回枚举常量在枚举中定义的顺序位置（从0开始计数）。

option（）配置参数的细节

promise

netty 的 Future 继承自 jdk 的Future，而 Promise 又对 netty Future 进行了扩展

netty Promise 不仅有 netty Future 的功能，而且脱离了任务独立存在，只作为两个线程间传递结果的容器

在IDEA中查看方法在哪被调用

IDEA小技巧

最右端黄，绿提示可以知道选中变量在哪里使用

IDEA查看接口全部实现类

找源码的时候，不要找接口，要找接口的实现类

Ctrl + Alt + B

IDEA查找某些方法

Ctrl + F12

享元模式

享元模式（Flyweight Pattern）是一种结构型设计模式，它旨在通过共享尽可能多的数据来最小化内存使用和提高性能。在享元模式中，对象被设计为可共享的，当需要创建新对象时，首先检查是否已经存在具有相同内部状态的对象，如果存在，则返回已存在的对象，否则创建一个新对象并将其加入到共享池中。这样可以减少内存占用，尤其是当有大量相似对象需要创建时。

在享元模式中，对象通常包括内部状态和外部状态两部分：

内部状态：对象的内部状态是不会改变的，可以被多个对象共享。内部状态存储在对象内部，并且不依赖于场景，因此可以被多个对象共享。
外部状态：对象的外部状态是会改变的，并且需要根据具体场景来设置。外部状态不能被共享，因此需要在对象外部进行管理。

通过将对象的内部状态和外部状态分离，享元模式可以实现对象的共享，从而节省内存和提高性能。

在实际应用中，享元模式通常与工厂模式结合使用，工厂模式负责创建和管理共享的对象，而享元模式负责实现对象的共享和复用。

直接内存和堆内存

在Java中，直接内存（Direct Memory）和堆内存（Heap Memory）是两种不同类型的内存分配方式。

直接内存（Direct Memory）：
- 直接内存是由操作系统管理的内存，不受Java虚拟机（JVM）的直接控制。
- 在Java中，可以通过java.nio包中的ByteBuffer类来操作直接内存。
- 直接内存的分配和释放是比较昂贵的操作，因为它涉及到操作系统的系统调用。
- 直接内存通常用于需要频繁读写的I/O操作，例如网络数据传输、文件操作等。
- 与堆内存相比，直接内存的分配和释放速度更快，但是开销更大。
堆内存（Heap Memory）：
- 堆内存是Java虚拟机管理的内存区域，用于存储对象实例和数组等数据结构。
- 在Java程序中，通过new关键字分配的对象都存储在堆内存中。
- 堆内存的分配和释放由垃圾回收器（Garbage Collector）负责，它会自动回收不再使用的对象以释放内存空间。
- 堆内存的分配和释放速度相对较慢，但是具有灵活性和自动管理的特点。
- 在Java中，堆内存是最常用的内存分配区域，几乎所有的对象实例都存储在堆内存中。
  总结：

直接内存是由操作系统管理的内存，用于高效的I/O操作，分配和释放速度快，但开销较大。
堆内存是Java虚拟机管理的内存区域，用于存储对象实例和数组，由垃圾回收器自动管理。
在实际开发中，需要根据具体的需求和性能要求来选择合适的内存分配方式，以获得最佳的性能和资源利用。

Java里面为什么会出现反射

java中引入反射（Reflection）的目的是为了使程序能够动态地获取类的信息、调用类的方法、操作类的字段等，而无需在编译时就确定类的名称、方法名或字段名。反射使得程序可以在运行时获取类的信息并对其进行操作，从而提高了程序的灵活性和可扩展性。

以下是一些Java中反射的常见用途和优点：

运行时动态加载类：通过反射，程序可以在运行时动态加载并实例化类，而无需在编译时就知道类的名称。
查找类的信息：反射允许程序在运行时查找和获取类的构造函数、方法、字段等信息，从而实现动态地操作这些类的成员。
动态调用方法：通过反射，程序可以在运行时动态地调用类的方法，从而实现一些动态化的业务逻辑。
编写通用性更强的代码：反射使得编写具有更高通用性的代码成为可能，例如编写框架、库或工具类时，可以通过反射来操作未知类的成员。
实现依赖注入和控制反转：一些框架和容器，如Spring框架，利用反射来实现依赖注入和控制反转，从而实现松耦合的组件之间的交互。

泛型

在Java中，泛型（Generics）是一种在编写类、接口和方法时，使其能够适用于多种数据类型的机制。泛型提供了编译时类型检查，并允许程序员在编写代码时指定或使用一种通用的类型，从而提高代码的灵活性和安全性。
以下是Java中泛型的主要用法：

泛型类（Generic Class）：

定义一个泛型类时，可以在类名后面添加尖括号，其中包含一个或多个类型参数。这些类型参数可以在类的方法和成员变量中使用。

示例：

public class Box<T> {
    private T value;
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}

泛型接口（Generic Interface）：
- 泛型接口的定义方式与泛型类类似，可以在接口名后面添加尖括号，并在接口的方法中使用类型参数。
- 示例：
```
public interface List<T> {
    void add(T element);
    T get(int index);
}
```
泛型方法（Generic Method）：
- 在方法的返回类型前面添加尖括号，并在方法参数中使用类型参数，以定义泛型方法。泛型方法可以在普通类、泛型类、泛型接口中定义。
- 示例：
```
public <T> T genericMethod(T value) {
    // 方法体
    return value;
}
```
通配符（Wildcard）：
- 使用通配符可以在泛型中表示一定范围内的类型，包括无界通配符 ?、上界通配符 <? extends T>、下界通配符 <? super T>。
- 示例：
```
public void processList(List<?> list) {
    // 处理任意类型的List
}
```
泛型限定（Bounded Generics）：
- 通过限定泛型的范围，可以确保泛型类型满足某些条件，如实现某个接口或继承某个类。
- 示例：
```
public <T extends Number> void processNumber(T number) {
    // 处理Number及其子类
}
```
  泛型的使用有助于提高代码的可读性、安全性和重用性。通过泛型，可以编写更通用、灵活的代码，减少重复代码的编写，并在编译时发现类型错误，而不是在运行时。

IDEA调试跳转到指定位置

IDEA ctrl+alt+向左箭头

快捷键就是ctrl+alt+←，可以实现跳转到刚刚浏览的那个文件的那行代码。

CAS是什么

CAS 是 “Compare and Swap” 的缩写，中文翻译为"比较并交换"。它是一种多线程同步的原子操作，常用于实现无锁的并发算法。
在计算机科学中，多线程环境下，当多个线程同时尝试更新同一块内存位置时，可能会引发竞态条件（Race Condition），导致数据不一致或其他问题。CAS 提供了一种机制，通过比较内存中的值与预期值是否相等，若相等则进行更新，否则不进行更新，从而避免了竞态条件。
CAS 操作通常包括三个操作数：

内存地址（或变量的引用）：即要进行读写的内存位置。
期望值：当前线程希望该内存位置的值是多少。
更新值：当前线程希望将内存位置的值更新为多少。
CAS 的操作过程如下：
读取内存地址的当前值。
比较当前值与期望值是否相等。
如果相等，则将更新值写入内存地址，操作成功。
如果不相等，则说明其他线程已经修改了内存值，操作失败。
CAS 操作是原子性的，即在执行过程中不会被中断。由于没有使用锁，CAS 操作通常比使用锁的方式更轻量级，适用于高并发的场景。然而，需要注意的是，CAS 也可能存在 ABA 问题，即在执行 CAS 操作的过程中，内存值可能被其他线程修改为相同的值，导致误判。
在 Java 中，java.util.concurrent 包提供了 AtomicXXX 类（如 AtomicInteger、AtomicLong），它们使用了 CAS 操作，提供了一些原子性的操作方法，帮助开发者更容易实现线程安全的并发编程。

ABA问题

ABA 问题是在并发编程中可能出现的一种情况，其中一个共享变量的值经过一系列操作从 A 变为 B，然后再变回 A。虽然最终的值和初始值相同，但是在这个过程中可能发生了其他的并发操作，导致程序逻辑出现问题。
具体来说，ABA 问题通常涉及到以下步骤：

初始时，一个共享变量的值为 A。
线程 T1 读取这个值，并执行一些操作，将其变为 B。
然后，线程 T1 将这个值又改回 A。
线程 T2 在没有意识到中间的操作的情况下，读取了这个值。
在这种情况下，线程 T2 可能会错误地认为共享变量的值一直是 A，因为它在最开始和最后都是 A。然而，实际上，由于中间发生了一系列操作，共享变量的状态已经发生了变化。
ABA 问题通常在使用 CAS（Compare and Swap）等无锁算法时可能出现。为了解决 ABA 问题，通常会引入版本号或者时间戳等机制，以确保在比较并交换时不仅仅检查数值是否相同，还需要考虑版本号或时间戳的一致性。这可以防止在变化的过程中其他线程对共享变量进行修改。
在 Java 中，java.util.concurrent 包提供了 AtomicStampedReference 类，它是对 AtomicReference 的扩展，引入了版本号的概念，帮助解决了一些 ABA 问题。

剖析源码要理解的主线

此文章用于笔者记录学习，也希望对你有帮助

李温候

关注

19
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Netty

笔者的Netty是跟着黑马的满老师学的，满老师直接封神！满老师和周阳老师是我心目中讲课最好的老师。Netty在网络编程中还是很重要的，也出现了以前从没有见过的名词，我都在笔记都记录了。满老师IDEA玩的贼溜，有很多使用IDEA的技巧，对看源码的帮助很大，跟着满老师学习一件很享受的事，有时间的话Netty源码部分值得我在刷一遍。
复制链接

扫一扫