Netty（基于NIO+Reactor）快速入门、同步、事件驱动、BIO、NIO（多路复用器selector）、Reactor线程模型

最新推荐文章于 2022-06-02 17:07:50 发布

原创最新推荐文章于 2022-06-02 17:07:50 发布 · 284 阅读

0 ·

CC 4.0 BY-SA版权

Netty 专栏收录该内容

2 篇文章

订阅专栏

Netty是一个基于NIO的高性能网络框架，它参考Reactor模式实现了主从Reactor多线程模型。Netty提供了一种更易用的方式来处理网络通信，避免了直接使用Java NIO的复杂性。在服务端，Netty通过NioEventLoopGroup和ServerBootstrap简化了服务器的启动流程，并能灵活调整缓冲区大小。在客户端，Netty的Bootstrap同样简化了连接过程，方便发送数据。文章还给出了简单的服务端和客户端示例代码。

在这里插入图片描述超级重要

在这里插入图片描述

Netty是基于NIO的
Netty其实是参考Reactor通过NIO实现的一个网络框架，可以写客服端和服务端代码
Netty就是一个网络框架

在这里插入图片描述

Netty核心架构：在这里插入图片描述

1.为什么选择Netty而不是原生NIO？

在这里插入图片描述
epoll空轮询：

在这里插入图片描述

2.java的io模型

在这里插入图片描述

（1）BIO 同步阻塞模型

在这里插入图片描述

并发不是很高可以用BIO，因为它比较简单

（2）NIO （异步）非阻塞IO

为了解决BIO的问题，所以出现了NIO
在这里插入图片描述

在这里插入图片描述

3.Reactor线程模型

在这里插入图片描述

（1）单Reactor单线程模型

在这里插入图片描述

（2）单Reactor多线程模型

这里的多线程是Handler那里的线程池，但缺点就来到了只有单个Reactor这里了

在这里插入图片描述

（3）主从Reactor多线程模型

在这里插入图片描述

4.Netty

Netty其实就是参考了主从Reactor模型通过NIO实现的
在这里插入图片描述

黑马netty小结：

在这里插入图片描述

这里参考：https://blog.youkuaiyun.com/qq_35190492/article/details/113174359

在这里插入图片描述

简单模板

服务端：

package com.yuan.day3.c2;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.AdaptiveRecvByteBufAllocator;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Server1 {
    void start() {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            // 调整系统的接收缓冲器（滑动窗口）
//            serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);
            // 调整 netty 的接收缓冲区（byteBuf）
            serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(16, 16, 16));
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new Server1().start();
    }
}

客户端：

package com.yuan.day3.c2;

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.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Client1 {
    static final Logger log = LoggerFactory.getLogger(Client1.class);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            send();
        }
        System.out.println("finish");
    }

    private static void send() {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        // 会在连接 channel 建立成功后，会触发 active 事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ByteBuf buf = ctx.alloc().buffer(16);
                            buf.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17});
                            ctx.writeAndFlush(buf);
                            ctx.channel().close();
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}