Qi

LLM Wiki 介绍：思想、意义、应用场景与优缺点

发表于 2026-06-05 分类于 mechine 8500 18 分钟

本文系统介绍 LLM Wiki 的核心思想、意义、应用场景与优缺点，采用中英文对照形式。LLM Wiki 是由 Andrej Karpathy 提出的一种个人知识库构建范式：用 LLM 将原始资料编译为结构化 Wiki 并持续维护，而非每次查询时重新检索。

This article introduces LLM Wiki—a personal knowledge-base pattern proposed by Andrej Karpathy—in a bilingual Chinese–English format, covering philosophy, significance, scenarios, and pros & cons.

核心操作包括 Ingest（摄入）、Query（查询）、Lint（巡检） 三大流程，采用 Raw / Wiki / Schema 三层架构……

Netty WebSocket协议开发

发表于 2023-08-14 分类于 framework 570 2 分钟

使用 Netty 开发基于 WebSocket 协议的应用是一个常见的场景。WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，通常用于实时性要求较高的应用，如聊天应用、实时数据展示等。下面是一个简单的示例，演示了如何使用 Netty 开发一个基于 WebSocket 的服务器应用。

首先，确保你已经引入了 Netty 的相关依赖，可以在项目的 pom.xml 文件中添加以下内容：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.66.Final</version>
</dependency>

接下来，创建一个简单的 Netty WebSocket 服务器应用示例：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;

public class WebSocketServerApp {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new HttpServerCodec());
                            ch.pipeline().addLast(new HttpObjectAggregator(65536)); // Aggregate HTTP messages
                            ch.pipeline().addLast(new WebSocketServerProtocolHandler("/ws")); // WebSocket protocol handler
                            ch.pipeline().addLast(new WebSocketHandler()); // Your WebSocket request handling logic
                        }
                    });

            ChannelFuture future = bootstrap.bind(8080).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

在上面的示例中，我们创建了一个简单的 WebSocket 服务器，监听在本地的 8080 端口。在 initChannel 方法中，我们添加了 HttpServerCodec、HttpObjectAggregator 和 WebSocketServerProtocolHandler 来处理 HTTP 和 WebSocket 握手。

你需要自己实现一个继承自 SimpleChannelInboundHandler<WebSocketFrame> 的 WebSocketHandler 类，用于处理接收到的 WebSocket 数据。例如：

import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler.HandshakeComplete;

public class WebSocketHandler extends SimpleChannelInboundHandler<WebSocketFrame> {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof HandshakeComplete) {
            // WebSocket handshake completed, remove the HTTP related handlers
            ctx.pipeline().remove(HttpServerCodec.class);
            ctx.pipeline().remove(HttpObjectAggregator.class);
        }
        super.userEventTriggered(ctx, evt);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) {
        if (frame instanceof TextWebSocketFrame) {
            String text = ((TextWebSocketFrame) frame).text();
            System.out.println("Received message: " + text);

            // Echo the received message back to the client
            ctx.writeAndFlush(new TextWebSocketFrame("Echo: " + text));
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

在上面的示例中，WebSocketHandler 类继承自 SimpleChannelInboundHandler<WebSocketFrame>，用于处理接收到的 WebSocket 数据帧。在 channelRead0 方法中，我们处理接收到的文本数据帧，并将其回显给客户端。

这只是一个简单的示例，实际的应用可能会更加复杂，需要处理更多的 WebSocket 数据帧类型、处理逻辑以及错误情况。但这个示例可以帮助你入门并理解如何使用 Netty 来开发基于 WebSocket 协议的应用。

Netty Http协议开发

发表于 2023-08-14 分类于 framework 539 2 分钟

使用 Netty 来开发基于 HTTP 协议的应用是相对常见的场景。HTTP 是一种基于请求-响应模式的应用层协议，用于在客户端和服务器之间传输数据。下面是一个简单的示例，演示了如何使用 Netty 开发一个基于 HTTP 的服务器应用。

首先，确保你已经引入了 Netty 的相关依赖，可以在项目的 pom.xml 文件中添加以下内容：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.66.Final</version>
</dependency>

接下来，创建一个简单的 Netty HTTP 服务器应用示例：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerHandler;

public class HttpServerApp {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new HttpServerCodec());
                            ch.pipeline().addLast(new HttpObjectAggregator(65536)); // Aggregate HTTP messages
                            ch.pipeline().addLast(new HttpServerHandler()); // Your HTTP request handling logic
                        }
                    });

            ChannelFuture future = bootstrap.bind(8080).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

在上面的示例中，我们创建了一个简单的 HTTP 服务器，监听在本地的 8080 端口。在 initChannel 方法中，我们添加了 HttpServerCodec（处理 HTTP 编解码）、HttpObjectAggregator（将 HTTP 消息聚合成 FullHttpRequest 或 FullHttpResponse）和自定义的 HttpServerHandler（处理 HTTP 请求）。

你需要自己实现一个继承自 ChannelInboundHandlerAdapter 的 HttpServerHandler 类，用于处理接收到的 HTTP 请求。例如：

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.codec.http.HttpVersion;

public class HttpServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg instanceof FullHttpRequest) {
            FullHttpRequest request = (FullHttpRequest) msg;
            String responseContent = "Hello, Netty HTTP Server!";
            sendHttpResponse(ctx, request, responseContent);
        }
    }

    private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest request, String content) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        response.content().writeBytes(content.getBytes());
        HttpUtil.setContentLength(response, response.content().readableBytes());
        ctx.writeAndFlush(response);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

在上面的示例中，HttpServerHandler 类重写了 channelRead 方法，处理接收到的 HTTP 请求。然后，它调用 sendHttpResponse 方法来构建并发送 HTTP 响应。

这只是一个简单的示例，实际的应用可能会更加复杂，需要处理更多的 HTTP 请求类型、处理逻辑以及错误情况。但这个示例可以帮助你入门并理解如何使用 Netty 来开发基于 HTTP 协议的应用。

直接内存与Netty零拷贝详解

发表于 2023-08-14 分类于 framework 561 2 分钟

直接内存（Direct Memory）和 Netty 的零拷贝（Zero-Copy）是在优化网络应用性能时常用的概念和技术。它们都涉及到减少数据在内存之间移动的操作，以提高数据传输的效率。让我们详细解释一下这两个概念。

直接内存（Direct Memory）：
直接内存是指在 JVM 堆之外分配的内存，通常通过 Java NIO 的 ByteBuffer 或者 Netty 中的 ByteBuf 来管理。相对于传统的堆内存（Heap Memory），直接内存的一个优势是可以减少堆内外的数据拷贝，从而提高数据传输性能。另一个优势是避免了垃圾回收对这部分内存的影响。

Netty 零拷贝（Zero-Copy）：
零拷贝是一种技术，旨在减少数据传输过程中的内存复制操作。在传统的数据传输过程中，数据从应用程序缓冲区（如 ByteBuffer）复制到操作系统内核缓冲区，然后再从内核缓冲区复制到网络适配器，最终发送出去。这些复制操作会占用CPU时间并降低性能。

Netty 零拷贝通过以下方式来优化这个过程：

使用直接内存：Netty 默认使用直接内存，数据可以直接从应用程序的直接内存传输到网络适配器，避免了应用程序和内核缓冲区之间的复制。
FileChannel.transferTo()：对于大文件传输，Netty 可以使用操作系统提供的 FileChannel.transferTo() 方法，使数据从文件通道直接传输到网络适配器，避免了数据的中间复制。
CompositeBuffer：Netty 的 CompositeBuffer 允许将多个缓冲区合并为一个逻辑上的缓冲区，这样在数据发送时可以避免将多个缓冲区合并复制到一个单独的缓冲区。

综上所述，直接内存和 Netty 零拷贝都是在优化数据传输性能方面的重要技术。它们能够减少数据在内存之间的复制，从而提高数据传输的效率。在网络应用开发中，合理使用直接内存和 Netty 零拷贝技术可以显著提升应用性能。

粘包拆包现象及解决方案

发表于 2023-08-14 分类于 framework 407 1 分钟

Netty 是一个基于 Java 的网络应用框架，提供了强大的网络编程能力。其中心跳机制是网络应用中常用的一种机制，用于检测连接是否存活，防止长时间没有数据传输导致连接断开。

下面是一个简单的示例，演示了如何在 Netty 中实现一个简单的心跳机制。请注意，这只是一个基本的示例，实际的应用中可能会更加复杂。

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.util.concurrent.TimeUnit;

public class HeartbeatClient {

    private static final String HOST = "localhost";
    private static final int PORT = 8888;

    public static void main(String[] args) {
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap()
                    .group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) {
                            ch.pipeline().addLast(new HeartbeatClientHandler());
                        }
                    });

            ChannelFuture future = bootstrap.connect(HOST, PORT).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }
}

class HeartbeatClientHandler extends ChannelInboundHandlerAdapter {
    private static final ByteBuf HEARTBEAT_SEQUENCE = ByteBufAllocator.DEFAULT.buffer().writeBytes("Heartbeat".getBytes());

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.executor().scheduleAtFixedRate(() -> {
            ctx.writeAndFlush(HEARTBEAT_SEQUENCE.duplicate());
        }, 0, 5, TimeUnit.SECONDS);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

在上面的示例中，HeartbeatClientHandler 类是一个自定义的处理器，它会在连接激活后每隔 5 秒向服务器发送一个心跳数据包。服务器端需要实现相应的处理逻辑来识别心跳包并进行处理，这样就能保持连接的存活状态。

需要注意的是，实际的生产环境中，心跳机制还需要考虑更多的情况，如超时、重连、心跳包的频率等。同时，Netty 提供了更高级的功能和 API，以便更好地实现稳定的心跳机制。

粘包拆包现象及解决方案

发表于 2023-08-14 分类于 framework 0 1 分钟

高性能序列化协议

发表于 2023-08-14 分类于 framework 596 2 分钟

在 Netty 中，高性能序列化协议是指在网络传输中，将对象序列化为字节流以进行传输，然后在接收端将字节流反序列化为对象。高性能序列化协议通常应该具备以下特点：

快速序列化与反序列化速度：在高性能应用中，序列化和反序列化的速度是关键因素。因此，高性能序列化协议应该能够以较低的开销进行快速序列化和反序列化操作。
高效的编码和解码：协议应该对数据进行高效的编码和解码，以减少网络传输的数据量，从而提高网络传输的效率。
小的序列化后的数据大小：序列化后的数据应该尽量小，以减少网络带宽的占用。
支持多种数据类型：协议应该支持多种数据类型的序列化和反序列化，包括基本数据类型、自定义对象等。
向前和向后兼容性：协议应该支持在不同版本之间进行兼容性的序列化和反序列化，以便在系统升级时能够平滑过渡。

在 Netty 中，有几种常见的高性能序列化协议：

**Google Protocol Buffers (Protobuf)**：Protobuf 是 Google 提供的一种高效的二进制序列化协议，具有很高的性能和压缩率。Netty 内置了对 Protobuf 的支持。
Apache Avro：Avro 是 Apache 基金会提供的一种数据序列化系统，支持动态数据模型，适用于动态数据结构的序列化。
MessagePack：MessagePack 是一种轻量级的二进制序列化格式，可以实现高速的序列化和反序列化操作。
Kryo：Kryo 是一个快速高效的 Java 序列化框架，能够在速度和大小之间找到一个平衡点。
FST：FST（Fast Serialization）是一种非常快速的 Java 序列化库，性能接近 Kryo，但通常会产生更小的序列化数据。

在选择高性能序列化协议时，需要根据应用场景和需求来进行选择。不同的协议可能在不同的方面有所优劣，所以需要综合考虑性能、开发便利性以及数据格式的大小等因素。

线程模型及源码剖析

发表于 2023-08-14 分类于 framework 594 2 分钟

Netty 是一个基于 NIO 的网络应用程序框架，具有高性能、高并发和灵活性等特点。它的线程模型是其核心设计之一，能够支持高效的网络通信。下面我将简要介绍 Netty 的线程模型以及对其源码的剖析。

Netty 线程模型：

Netty 的线程模型基于 Reactor 模式，通过多线程处理并发连接和 I/O 操作，以提高性能。Netty 的线程模型可以分为三部分：

老板线程（Boss Threads）：也称为 Acceptor 线程，负责处理客户端连接的接收，并将连接注册到工作线程中的 Selector 上。
工作线程（Worker Threads）：每个工作线程都包含一个 Selector，负责处理已连接的客户端请求，包括读写等操作。
业务线程（Business Threads）：在工作线程中，业务线程负责处理具体的业务逻辑，以免阻塞 I/O 线程。

Netty 源码剖析：

深入理解 Netty 的源码涉及多个模块和类，以下是一些关键的类和模块：

EventLoopGroup 和 EventLoop：EventLoopGroup 包含一组 EventLoop，负责处理 I/O 事件。EventLoop 是一个线程，通过 Selector 轮询 I/O 事件，然后将事件分发给相关的 Channel。
Channel：Channel 表示一个通道，可以是网络连接、文件等。它包含了与 I/O 相关的操作和状态。
Bootstrap 和 ServerBootstrap：这些类是配置和启动 Netty 的入口，用于设置连接参数和处理器等。
Pipeline 和 ChannelHandler：Pipeline 是一个处理器链，包含了多个 ChannelHandler，用于处理各种事件和操作。
ByteBuf：Netty 提供了高效的字节缓冲区，用于读写数据，具有可读性、可写性、引用计数等特点。
Future 和 Promise：Future 表示异步操作的结果，Promise 表示一个异步操作的可写入结果。

理解 Netty 的源码需要对 Java NIO 和网络编程有一定的了解，以及对事件驱动编程有基本的理解。你可以通过阅读 Netty 的官方文档和源码，深入了解其核心组件的设计和工作原理。从 EventLoopGroup、ChannelPipeline、ChannelHandler 等类开始，逐步追踪和分析其调用关系和内部实现，以便更好地理解 Netty 的线程模型和网络通信机制。

Netty BIO、NIO及AIO线程模型详解

发表于 2023-08-14 分类于 framework 0 1 分钟

Netty 网络与IO模型基础进阶

发表于 2023-08-14 分类于 framework 685 2 分钟

Netty 是一个开源的异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的网络服务器和客户端。它支持多种传输协议和网络协议，提供了丰富的工具和组件，使网络编程变得更加简单和灵活。Netty 的网络与 I/O 模型是其核心特点之一，下面是关于 Netty 的网络和 I/O 模型的基础知识：

网络模型：

Netty 提供了两种主要的网络模型：阻塞 I/O 和非阻塞 I/O。

阻塞 I/O（Blocking I/O）：
在阻塞 I/O 模型中，当应用程序发起一个 I/O 操作（比如读或写），它会一直等待，直到操作完成或发生错误。在这期间，线程会被阻塞，无法执行其他任务。这种模型在连接数量较少时适用，但在高并发场景下可能导致资源的浪费。
非阻塞 I/O（Non-blocking I/O）：
在非阻塞 I/O 模型中，应用程序发起一个 I/O 操作后，它不会等待操作完成，而是继续执行其他任务。通过不断地轮询 I/O 操作的状态，可以实现异步处理多个连接。这种模型在高并发场景下更加适用，但需要使用轮询来检查 I/O 操作的状态。

I/O 模型：

Netty 支持多种 I/O 模型，用于处理 I/O 操作。

阻塞 I/O（Blocking I/O）：使用 Java 原生的阻塞 I/O，适用于连接数量较少，且对延迟要求不高的场景。
非阻塞 I/O（Non-blocking I/O）：使用 Java NIO，通过 Selector 轮询非阻塞的 I/O 通道，适用于高并发场景。
多路复用 I/O（Multiplexing I/O）：通过操作系统提供的系统调用（如 epoll、kqueue）来实现高效的事件驱动模型，适用于大规模连接和高并发场景，是 Netty 最常用的模型。
异步 I/O（Asynchronous I/O）：使用 Java NIO 2 中的异步 I/O 特性，适用于需要高性能和低延迟的场景。

Netty 的异步模型：

Netty 使用了非阻塞 I/O 模型，结合事件驱动机制，实现了高性能的异步网络编程。它通过 Selector 来管理多个连接，通过事件回调机制来处理不同的网络事件，避免了线程阻塞，提升了并发性能。

总的来说，Netty 的网络和 I/O 模型使其成为构建高性能网络应用程序的优秀框架，可以根据实际需求选择合适的模型来实现高效的网络通信。

Dubbo 调用模块详解

发表于 2023-08-14 分类于 framework 0 1 分钟