网络编程之Netty

一只懒惰的小虫子

已于 2022-05-24 16:16:01 修改

阅读量1.1k

点赞数 4

分类专栏：网络编程文章标签：网络 java

于 2022-05-23 11:21:13 首次发布

本文链接：https://blog.youkuaiyun.com/Strange_boy/article/details/124708542

版权

原文链接

概述

Netty 是一个高性能、异步事件驱动的 NIO 框架

优点

1、高性能、高吞吐量、低延迟
2、使用方便，详细的Javadoc,用户指南和示例
3、社区活跃，版本迭代周期短
4、设计优雅，适用于各种传输类型的统一API阻塞和非阻塞Socket；基于灵活且可扩展的事件模型

线程模型介绍

目前的线程模型有：传统阻塞I/O服务模型、Reactor模型；
根据Reactor数量和处理资源线程的的数量不同，有3种形式：
1、单Reactor
2、单Reactor多线程
3、主从Reactor多线程
Netty主要基于主从Reactor多线程模型做了一定的改进，其中主从Reactor多线程模型有多个Reactor

传统阻塞I/O服务模型

特点
1、采用阻塞IO模式获取数据输入的数据
2、每个连接都需要独立的线程完成数据的输入，业务处理，数据返回
问题
1、当并发数很大时，会创建大量的线程，占用很大的系统资源
2、连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在read操作，造成资源浪费
在这里插入图片描述
注：黄色框表示对象，蓝色框表示线程，白色框表示方法

Reactor模式（反应器模式/分发者模式/通知者模式）

针对传统阻塞I/O服务模型的2个缺点的解决方案：
1、基于I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有的连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。
2、基于线程池复用线程资源：不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。
复用结合线程池，就是Reactor模式基本设计思想
在这里插入图片描述

说明
1、Reactor模式，通过一个或多个输入同时传递给服务处理器的模式（基于事件驱动）
2、服务端程序处理传入的多个请求，并将它们同步分派到相应的处理器线程，因此Reactor模式也叫Dispatcher模式
3、Reactor模式使用IO复用监听事件，收到事件后，分发给某个线程(进程)，这就是网络服务器处理高并发的关键

Reactor模式的优点

1、响应快，不必为单个同步时间所阻塞，虽然Reactor本身依然是同步的
2、可以最大程度的避免复杂的多线程问题及同步问题，并且避免了多线程/进程的切换开销
3、扩展性好，可以方便的通过增加Reactor实例个数来充分利用CPU资源
4、复用性好，Reactor模型本身与事件处理逻辑无关，具有很高的复用性

单Reactor单线程

在这里插入图片描述
1、Select 是前面I/O复用模型的标准网络编程API，可以实现应用程序通过一个阻塞对象监听多路连接请求
2、Reactor对象通过Select监控客户端请求事件，收到事件后通过Dispatch进行分发
3、如果是建立连接请求事件，则由Accepor通过Accept处理连接请求，然后创建一个Handler对象连接完成后的后续业务处理
4、如果不是建立连接事件，则Reactor会分发调用连接对象对应的Handler来响应
5、Handler会完成Read->业务处理->send的完整业务流程
优点
模型简单，没有多线程、进程通讯、竞争的问题，全都在一个进程中完成。
缺点
1、性能问题，只有一个线程，无法完全发挥多核CPU的性能，Handler在处理某个连接的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈
2、可靠性问题，线程意外终止，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障
使用场景
客户端的数量有限，业务处理非常快速，比如Redis在业务处理的时间复杂度O（1）的情况

单Reactor多线程

在这里插入图片描述
1、Reactor对象通过select监控客户端请求事件，收到事件后，通过dispatch进行分发
2、如果建立连接请求，则由Acceptor通过accetp处理连接请求，然后创建一个Handler对象处理完成连接后的各种事件
3、如果不是连接请求，则由Reactor分发调用连接对应的handler来处理
4、handler只负责响应事件，不做具体的业务处理，通过read读取数据后，会分发给后面的worker线程池的某个线程处理业务
5、worker线程池会分配独立线程完成真正的业务，并将结果返回给handler
6、hanlder收到响应后，通过send将结果返回给client
优点
可以充分利用多核CPU的处理能力
缺点
多线程下数据共享和访问比较复杂，reactor处理所有事件的监听和响应。单线程运行，高并发场景下容易出现性能瓶颈

主从Reactor多线程

在这里插入图片描述

1、Reactor主线程MainReactor对象通过select监听连接事件，收到事件后，通过Acceptor处理连接事件
2、当Acceptor处理连接事件后，MainReactor将连接分配给SubReactor
3、SubReactor将连接加入到连接队列进行监听，并创建handler进行各种事件处理
4、当有事件发生时，SubReactor就会调用相应的handler处理
5、handler通过read读取数据，分发给worker线程处理
6、worker线程池分配独立的worker线程进行业务处理，并返回结果
7、handler收到响应的结果后，再通过send将结果返回给client
8、Reactor主线程可以对应多个Reactor子线程，即MainReactor可以关联多个SubReactor
优点
1、父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理
2、父线程与子线程的数据交互简单，Reactor只需要把新连接传给子线程，子线程无需返回数据
缺点
编程复杂度较高

Netty模型

简单版

在这里插入图片描述
1、BossGroup线程维护Selector，只关注Accept
2、当接收到Accept事件，获取到对应的AocketChannel，封装成NIOSocketChannel并注册到Worker线程（事件循环），并进行维护
3、当Worker线程监听到selector中通道发生自己感兴趣的事件后，就进行处理(hanlder),此时handler已经加入到通道

进阶版

在这里插入图片描述

1、有两组线程池：BossGroup和WorkerGroup, BossGroup中的线程（可以有多个），专门负责客户端连接，WorkerGroup中的线程专门负责连接上的读写。
2、BossGroup和WorkerGroup含有多个不断循环的执行事件处理的线程，每个线程都包含一个Selector, 用于监听注册在其上的Channel
3、每个BossGroup中的线程循环执行以下三个步骤：
3.1 轮询注册在其上的ServerSocketChannel的accept事件（OP_ACCEPT事件）
3.2 处理accept事件，与客户端建立连接，生成一个NioSocketChannel，并将其注册到WorkerGroup中某一个线程上的Selector上
3.3 再去以此循环处理任务队列中的下一个事件
4、每个WokerGroup中的线程循环执行以下三个步骤：
4.1 轮询注册在其上的NIOSocketChannel 的read/write事件（OP_READ/OP_WRITE事件）
4.2 在对应的NIOSocketChannel上处理read/write事件
4.3 再去以此循环处理任务队列中的下一个事件

详细版

在这里插入图片描述
1、Netty抽象出两组线程池BossGroup专门负责接收客户端的连接，WorkerGroup专门负责网络的读写
2、BossGroup和WorkerGroup类型都是NioEventLoopGroup
3、NioEventLoopGroup相当于一个事件循环组，这个组中含有多个事件循环，每一个事件循环是NioEventLoop
4、NioEventLoop表示一个不断循环的执行处理任务的线程，每个NioEventLoop都有一个Selector，用于监听绑定在其上的socket的网络通讯
5、NioEventLoopGroup可以有多个线程，即可以含有多个NioEventLoop
6、每个BossNioEventLoop循环执行的步骤有3个：
6.1 轮询accept事件
6.2 处理accept事件，与client建立连接，生成NioSocketChannel，并将其注册到某个WorkerNioEventLoop上的Selector
6.3 处理任务队列的任务，即runAllTasks
7、每个WorkerNioEventLoop循环执行的步骤
7.1 轮询read,write事件
7.2 处理i/o事件，即read,write事件，在对应NioSocketChannel处理
7.3处理任务队列的任务，即runAllTasks
8、每个WorkerNioEventLoop处理业务时，会使用pipeLine(管道)，pipeline中包含了channel，即通过pipeline可以获取到对应的通道，管道中维护了很多的处理器

入门实例

要求
1、Netty在 6668端口监听，客户端能发送消息给服务端 “hello, server”
2、服务器可以回复消息给客户端 “hello, client”

服务端

package com.tk.netty.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
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.NioServerSocketChannel;

/**
 * netty服务器
 *
 * @author taoke
 * @date 2022/5/16
 */
public class NettyServer {
   

    public static void main(String[] args) {
   
        //创建BossGroup和WorkerGroup
        //1、创建两个线程组BossGroup和WorkerGroup
        //2、bossGroup知识2处理连接请求，真正的和客户端处理业务，会交给workerGroup完成
        //3、两个都是无线循环
        //4、bossGroup和workerGroup含有的子进程（NioEventLoop）的个数
        //默认实际cpu核数 *2
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
   
            //创建服务端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            //使用链式编程进行设置
            bootstrap.group(bossGroup, workerGroup)//设置两个线程组
                    .channel(NioServerSocketChannel.class)//使用NioSocketChannel作为服务器的通道
                    .option(ChannelOption.SO_BACKLOG, 128)//设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {
   //设置处理器
                        @Override
                        protected void initChannel(SocketChannel ch) {
   
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("server is ready。。。");
            //绑定一个端口并且同步，生成了一个ChannelFuture对象
            //启动服务器（并绑定端口）
            ChannelFuture cf = bootstrap.bind(6668).sync();
            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

服务端处理器

package com.tk.netty.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.CharsetUtil;

/**
 * 自定义handler
 *
 * @author taoke
 * @date 2022/5/16
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
   

    /**
     * 读取数据（可以读取客户端发送的消息）
     *
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     * @param msg 客户端发送的数据
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
   
        System.out.println("服务器读取线程：" + Thread.currentThread().getName());
        System.out.println("server ctx=" + ctx);
        System.out.println("channel 和 pipeline的关系");
        ChannelPipeline pipeline = ctx.pipeline();//本质是一个双向链表
        Channel channel = ctx.channel();

        //将msg转成一个ByteBuf
        //ByteBuf是Netty提供的,不是Nio的ByteBuf
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送消息是：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址：" + channel.remoteAddress());
    }

    /**
     * 数据读取完毕
     *
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
   
        //相当于 write+flush
        //将数据写入缓存，并刷新
        //对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,client", CharsetUtil.UTF_8));
    }

    /**
     * 处理异常，关闭通道
     *
     * @param ctx   上下文对象，含有管道pipeline,通道channel，地址
     * @param cause 异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
   
        cause.printStackTrace();
        ctx.close();
    }
}

客户端

package com.tk.netty.netty;

import io.netty.bootstrap.Bootstrap;
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.NioSocketChannel;

/**
 * netty客户端
 *
 * @author taoke
 * @date 2022/5/16
 */
public class NettyClient {
   

    public static void main(String[] args) {
   
        //客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
   
            //创建客户端启动对象
            //注意客户端使用的不是ServerBootStrap而是BootStrap
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)//设置线程组
                    .channel(NioSocketChannel.class)//设置客户端通道的实现类（反射）
                    .handler(new ChannelInitializer<SocketChannel>() {
   
                        @Override
                        protected void initChannel(SocketChannel socketChannel) {
   
                            socketChannel.pipeline().addLast(new NettyClientHandler());
                        }
                    });
            System.out.println("client is ready。。。");
            //启动客户端去连接服务器
            //关于ChannelFuture要分析，涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
            //给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {
   
            e.printStackTrace();
        } finally {
   
            group.shutdownGracefully();
        }
    }
}

客户端处理器

package com.tk.netty.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
   
    /**
     * 通道就绪触发
     *
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
   
        System.out.println("client:" + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,server...", CharsetUtil.UTF_8));
    }

    /**
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     * @param msg 服务端发送的数据
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
   
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务端回复的消息：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址：" + ctx.channel().remoteAddress());
    }

    /**
     * 处理异常，关闭通道
     *
     * @param ctx   上下文对象，含有管道pipeline,通道channel，地址
     * @param cause 异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
   
        cause.printStackTrace();
        ctx.close();
    }
}

运行结果
服务端启动，在6668端口监听
在这里插入图片描述
客户端进行连接

任务队列(Task)

使用场景

1、用户程序自定义的普通任务
2、用户自定义定时任务
3、非当前Reactor线程调用Channel的各种方法。例如在推送系统的业务线程里面，根据用户的标识，找到对应的Channel引用，然后调用Write类方法向该用户推送消息，就会进入到这种场景。最终的Write会提交到任务队列中后被异步消费。

代码演示

package com.tk.netty.netty;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

import java.util.concurrent.TimeUnit;

/**
 * 自定义handler
 *  * @author taoke
 * @date 2022/5/16
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
   

    /**
     * 读取数据（可以读取客户端发送的消息）
     *
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     * @param msg 客户端发送的数据
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
   
        //比如这里我们有一个耗时的操作-> 异步执行-> 提交该channel对应的NioEventLoop的taskQueue中
        //解决方案1 用户程序自定义的普通任务
        ctx.channel().eventLoop().execute(() -> {
   
            try {
   
                Thread.sleep(5000);
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello client2", CharsetUtil.UTF_8));
                System.out.println("channel hashcode=" + ctx.channel().hashCode());
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        });

        ctx.channel().eventLoop().execute(() -> {
   
            try {
   
                Thread.sleep(5000);
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello client3", CharsetUtil.UTF_8));
                System.out.println("channel hashcode=" + ctx.channel().hashCode());
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        });

        //解决方案2：用户自定义定时任务->该任务是提交到scheduledTaskQueue中
        ctx.channel().eventLoop().schedule(() -> {
   
            try {
   
                Thread.sleep(5000);
                ctx.writeAndFlush(Unpooled.copiedBuffer("hello client4", CharsetUtil.UTF_8));
                System.out.println("channel hashcode=" + ctx.channel().hashCode());
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }, 5, TimeUnit.SECONDS);

        System.out.println("go on 。。。");

    }


    /**
     * 数据读取完毕
     *
     * @param ctx 上下文对象，含有管道pipeline,通道channel，地址
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
   
        //相当于 write+flush
        //将数据写入缓存，并刷新
        //对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,client", CharsetUtil.UTF_8));
    }

    /**
     * 处理异常，关闭通道
     *
     * @param ctx   上下文对象，含有管道pipeline,通道channel，地址
     * @param cause 异常
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
   
        cause.printStackTrace();
        ctx.close();
    }
}

运行结果
服务端
在这里插入图片描述
客户端

说明
1、Netty抽象出两组线程池，BossGroup专门负责接收客户端连接，WorkerGroup专门负责网络读写操作
2、NioEventLoop标识一个不断循环执行任务的线程组，每个NioEventLoop都有一个Selector，用于监听绑定在其上的socket网络通道
3、NioEventLoop内部采用串行化设计，从消息的读取->解码->处理->编码->发送，始终由IO线程NioEventLoop负责

NioEventLoopGroup下包含多个NioEventLoop
每个NioEventLoop中包含有一个Selector，一个taskWueue
NioEventLoop的Selector上可以注册监听多个NioChannel
每个NioChannel只会绑定在唯一的NioEventLoop上
每个NioChannel都绑定有一个自己的ChannelPipeline

异步模型

基本介绍

1、异步的概念和同步相对，当一个异步过程调用发出后，调用者不能立刻得到结果，实际处理这个调用的组件在完成之后，通过状态，通知，和回调来通知调用者
2、Netty中的I/O操作是异步的，包括Bind、Write、Connetct等操作会简单的返回液体个ChannelFuture
3、调用者并不能立刻获得结果，而是通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果
4、Netty的异步模型是建立在future和callback上的。callback就是回调，重点说Future，它的核心思想是：假设一个方法fun,计算过程可能非常耗时，等待fun返回显然不合适，那么可以在调用fun的时候，立马返回一个Future，后续可以通过Future去监控方法fun的处理过程（即Future-Listener机制）

Future说明

1、表示异步的执行结果，可以通过它提供的方法来检测执行是否完成，比如检索计算等等
2、ChannelFuture是一个接口：public interface ChnnaelFuture extends Future 我们可以添加监听器，当监听的事件发生时，就会通知到监听器

Future-Listener机制

1、当Future对象刚刚创建时，处于非完成状态，调用者可以通过返回的ChannelFuture来获取操作执行的状态，注册监听函数来执行完成后的操作
2、常见有如下的操作

通过isDone方法来判断当前操作是否完成；
通过isSuccess方法来判断已完成的当前操作是否成功
通过getCause方法来获取已完成的当前操作失败的原因
通过isCanceled方法判断已完成的当前操作是否被取消
通过addListener方法来注册监听器，当操作已完成（isDone方法返回完成），将会通知指定的监听器；如果Future对象已完成，则通知指定的监听器

举例说明

绑定端口是异步操作，当绑定操作处理完，将会调用相应的监听器处理逻辑

 ChannelFuture cf = bootstrap.bind(6668).sync();
            cf.addListener((ChannelFutureListener) channelFuture -> {
   
                if(cf.isSuccess()){
   
                    System.out.println("监听端口 6668 成功！");
                }else{
   
                    System.out.println("监听端口 6668 失败!");
                }
            });

实例-HTTP服务

1、Nett

最低0.47元/天解锁文章