重新开始---sgg-netty----5

最新推荐文章于 2022-01-06 17:37:27 发布

nzch

最新推荐文章于 2022-01-06 17:37:27 发布

阅读量240

点赞数

分类专栏： netty

本文链接：https://blog.csdn.net/qq_28764557/article/details/104891516

版权

netty 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

主从的Reactor多线程：

这个模型reactor只管我自己的这块的事情：

1.reactor只管1

2.子reactor管2

reactor只负责连接请求。

总结：

我自己的总结：

单reactor单线程：都是自己处理，我们之前的NIO模型

单reactor多线程：handler处理的是具体的事件，还是单线程去处理的连接和请求。

主从reactor：mainReactor只负责连接，子线程分发请求，在线程池处理请求。

-----------------------------------------------------------------41------------------------------------------------------------

BossGroup可以是多个线程也就是可以是线程池的，每一个线程是一个NioEventLoop，不断的循环连接事件。

同理WorkGroup。

主从的。

NioEvevtLoop事件循环主要处理具体io事件处理io事件处理任务队列

--------------------------------------------------42------------------------------------------------------------

netty比较完整的模型：

NioEventLoopGroup是一个事件循环组，里面有很对的事件循环。每个NioEventLoop都有一个selector。

PipeLine：包含channel，通过PipeLine获取channel，内部可以包含很多的处理器。

--------------------------------------------------43------------------------------------------------------------

netty快速入门TCP。

代码：引入netty。

版本4.1.2

代码：

 public static void main(String[] args) throws Exception {
        //创建BossGroup 和 WorkerGroup
        //说明
        //1. 创建两个线程组 bossGroup 和 workerGroup
        //2. bossGroup 只是处理连接请求 , 真正的和客户端业务处理，会交给 workerGroup完成
        //3. 两个都是无限循环
        //4. bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数
        //   默认实际 cpu核数 * 2
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(); //8
        try {
            //创建服务器端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            //使用链式编程来进行设置
            bootstrap.group(bossGroup, workerGroup) //设置两个线程组
                    .channel(NioServerSocketChannel.class) //使用NioServerSocketChannel 作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true) //设置保持活动连接状态
//                    .handler(null) // 该 handler对应 bossGroup , childHandler 对应 workerGroup
                    .childHandler(new ChannelInitializer<SocketChannel>() {//创建一个通道初始化对象(匿名对象)
                        //给pipeline 设置处理器
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            System.out.println("客户socketchannel hashcode=" + ch.hashCode()); //可以使用一个集合管理 SocketChannel， 再推送消息时，可以将业务加入到各个channel 对应的 NIOEventLoop 的 taskQueue 或者 scheduleTaskQueue
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    }); // 给我们的workerGroup 的 EventLoop 对应的管道设置处理器
            System.out.println(".....服务器 is ready...");
            //绑定一个端口并且同步, 生成了一个 ChannelFuture 对象
            //启动服务器(并绑定端口)
            ChannelFuture cf = bootstrap.bind(6668).sync();
            //给cf 注册监听器，监控我们关心的事件
            cf.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (cf.isSuccess()) {
                        System.out.println("监听端口 6668 成功");
                    } else {
                        System.out.println("监听端口 6668 失败");
                    }
                }
            });
            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

---

第一步：

第二步：服务器的准备

第三步：绑定端口

--------------------------------------------------44------------------------------------------------------------

适配器模式：https://blog.csdn.net/qq_28764557/article/details/100591930

代码截图：

当有数据读取的时候这个channelRead就会被触发。

NIO拿到数据要放缓存里面。

我们还要把数据返回给客户端client：

代码：

 @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //将 msg 转成一个 ByteBuf
        //ByteBuf 是 Netty 提供的，不是 NIO 的 ByteBuffer.
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址:" + channel.remoteAddress());
    }

返回给客户端：

//数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //writeAndFlush 是 write + flush
        //将数据写入到缓存，并刷新
        //一般讲，我们对这个发送的数据进行编码
        //Unpooled只是编码罢了
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵1", CharsetUtil.UTF_8));
    }

发送要编码的一定记住。

处理异常：

//处理异常, 一般是需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }

加入到pipline：

遇到异常优雅的关闭netty：

------------------------------------------------------------------45----------------------------------------------------------------

写netty的客户端：

public class NettyClient {
    public static void main(String[] args) throws Exception {
        //客户端需要一个事件循环组
        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 ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler()); //加入自己的处理器
                        }
                    });
            System.out.println("客户端 ok..");
            //启动客户端去连接服务器端
            //关于 ChannelFuture 要分析，涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
            //给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }
    }
}

学nettyClientHandler去实际的处理我们的请求。

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    //通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client " + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello, server: (>^ω^<)喵", CharsetUtil.UTF_8));
    }
    //当通道有读取事件时，会触发,基于事件的触发的NIO是select的轮询的
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器回复的消息:" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址： "+ ctx.channel().remoteAddress());
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

起两个客户端：

为什么是两个线程：不一定的，看是不是绑定到了一个selector。

测试看下服务器端和客户端是不是能正确的运行。

结合框架去分析：

netty模型：http://ifeve.com/%E8%B0%88%E8%B0%88netty%E7%9A%84%E7%BA%BF%E7%A8%8B%E6%A8%A1%E5%9E%8B/

----------------------------------------------------------46----------------------------------------------------------------

第一个问题：

程序写完了，看下和我们分析的netty模型是不是可以对应上呢？

这两个你不指定的话都是cpu核数*2的。

看下，默认情况下会产生8个事件循环的。

存在了EventExcutor。

----

第二个问题：

我们设置bossGroup和workerGroup分别为1和8，然后看下连接8个客户端看下如何分配线程。

一次分配到eventLoop，一个eventLoop是一个线程。

最开始:

多个客户端

------

第三个问题：

我们看下NioEventLoop，每一个NioEventLoop有自己的selector。

每一个nioEventLoop都有一个selector去不停的循环的，等待相应的读写事件。

---

看下channel和pipline的关系，还有上下文是什么。

看下channel和pipline的关系，pipline本质是一个双向的链表。

目前是入栈的状态。

看出：pipline本质是一个双向链表

关系：channel和pipline是相互包含的我中有你你中有我 ctx信息更全都包含了

--------------------------------------------------47------------------------------------------------------------

回顾：

内容梳理：

核心的组成：

--------------------------------------------------48------------------------------------------------------------

我们分析一个问题，加入我们的一个handler处理的问题时间很长是会引起阻塞的。

提交到taskQueue去执行。

异步消费是关键，就是可以提前返回的。

一个通道就是一个socket连接。

在服务端的handler加入如下的代码：

效果：
客户端和服务器端实际上是被阻塞了。

我们再理解一遍这个基础的程序：

一个线程一个NioEventLoop。

解决方案1：我们做完就会把任务提交到当前的nioEventLoop的taskQueue中去的。

 //比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel 对应的
        //NIOEventLoop 的 taskQueue中,每个事件循环有自己的selector
        //解决方案1 用户程序自定义的普通任务
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5 * 1000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵2", CharsetUtil.UTF_8));
                    System.out.println("channel code=" + ctx.channel().hashCode());
                } catch (Exception ex) {
                    System.out.println("发生异常" + ex.getMessage());
                }
            }
        });
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5 * 1000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵3", CharsetUtil.UTF_8));
                    System.out.println("channel code=" + ctx.channel().hashCode());
                } catch (Exception ex) {
                    System.out.println("发生异常" + ex.getMessage());
                }
            }
        });

我们看下源码，为什么说放在了taskQueue里面了呢？

注意这个taskqueue在NioEventLoop中。

注意这个再加一个任务。

再加一个任务是5+5才发送过去的。注意是任务队列。是串行的。

再加一个任务。

此时taskqueue：

客户端的代码：

看下结果，喵1马上就能得到，再等5+5=10s则得到喵2.

理解这句话：

一个selector可以注册多个channnel也就是多个socket。是轮询的1 2 3 4 5 6 7 8 1 2 3.。。。。

--------------------------------------------------49------------------------------------------------------------

第二种方法：

用户自定义定时任务 -》 该任务是提交到 scheduleTaskQueue中

  ctx.channel().eventLoop().schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    // 延时5秒
                    Thread.sleep(5 * 1000);
                    ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵4", CharsetUtil.UTF_8));
                    System.out.println("channel code=" + ctx.channel().hashCode());
                } catch (Exception ex) {
                    System.out.println("发生异常" + ex.getMessage());
                }
            }
        }, 5, TimeUnit.SECONDS);