插入系列 什么是netty

一．Netty先容 1.什么是netty

Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网罗应用设施框架，用以快速开辟高性能、高可靠性的网罗 IO 设施，是当今最流行的 NIO 框架，Netty 在互联网边界、大数据散播式盘算推算边界、游戏行业、通讯行业等获取了平日的应用插入系列，着名的 Elasticsearch 、Dubbo 框架里面都弃取了 Netty。

2.为什么要用netty

原生 NIO 存在问题:

1.NIO 的类库和 API 芜乱

2.需要熟谙 Java 多线程编程，因为 NIO 编程触及到 Reactor 景色，必须对多线程和网罗编程相配熟谙， 才智编写出高质地的 NIO 设施

3.开辟职责量和难度都相配大。举例客户端面对断连重连、网罗闪断、半包读写、失败缓存、网罗拥塞和格外  流的处理等等处理起来难度会比拟大。

4.JDK NIO 的 Bug：举例恶名昭著的 Epoll Bug，它会导致 Selector 空轮询，最终导致 CPU 100%。直到 JDK 1.7 版块该问题仍旧存在，莫得被根底解决。

3.Netty的优点

Netty 对 JDK 自带的 NIO 的 API 进行了封装，解决了上述问题。

1.想象优雅：适用于多样传输类型的斡旋 API 阻拦和非阻拦 Socket；基于天真且可扩张的事件模子，不错明晰地折柳热心点；高度可定制的线程模子 - 单线程，一个或多个线程池.

2.使用浅易：防范纪录的 Javadoc，用户指南和示例；莫得其他依赖项，JDK 5（Netty 3.x）或 6（Netty 4.x）就充足了。

3.高性能、费解量更高：蔓延更低；减少资源耗尽；最小化无须要的内存复制。

4.安全：无缺的 SSL/TLS 和 StartTLS 支抓。

5.社区活跃、束缚更新：社区活跃，版块迭代周期短，发现的 Bug 不错被实时竖立，同期更多的新功能会被加入

二．Reactor三种线程模子 1.现存的三种线程模子

不同的线程景色，对设施的性能有很大影响，当今存在的线程模子有：

①.传统阻拦 I/O 作事模子 ②Reactor 景色

Reactor 景色又有 3 种典型的达成

单 Reactor 单线程；

单 Reactor 多线程；

主从 Reactor 多线程

Netty 的线程模子是主如若基于主从 Reactor 多线程模子改成了主从 Reactor 多线程模子有多个 Reactor景色

2.传统阻拦 I/O 作事模子先容

特色：

弃取阻拦IO景色获取输入的数据

每个取悦都需要创建单独的线程完成数据的输入，业务处理和数据的复返

流弊：

当并发数很大，就会创建大量的线程，占用很大系统资源，在线程支出和高下文切换上缩小处感性能

当取悦创建后，如果现时方程暂时没特别据可读，该线程会阻拦在read 操作，变成线程资源的浮滥。

 

图片

黄色的框暗意对象， 蓝色的框暗意线程 白色的框暗意方法(API)

3. Reactor 景色

针对传统阻拦 I/O 作事模子的 2 个流弊，解决有考虑：

I/O 复用模子：多个取悦共用一个阻拦对象，应用设施只需要在一个阻拦对象上恭候，无需阻拦恭候通盘取悦。当某个取悦有新的数据不错处理时，操作系统示知应用设施，线程从阻拦气象复返，运转进行业务处理。

Reactor 对应的叫法: 1. 反应器景色 2. 分发者景色(Dispatcher) 3. 示知者景色(notifier)

基于线程池复用线程资源景色：无须再为每个取悦创建线程，将取悦完成后的业务处理任务分配给线程进行处理，一个线程不错处理多个取悦的业务。

I/O 复用联结线程池，即是 Reactor 景色基本想象想想

 

图片

Reactor 景色，通过一个或多个输入同期传递给作事处理器的景色，(基于事件驱动)

作事器端设施处理传入的多个申请，并将它们同步分拨到相应的处理线程插入系列， 因此Reactor景色也叫 Dispatcher景色

Reactor 景色使用IO复用监听事件， 收到事件后，分发给某个线程(程度)， 这点即是网罗作事器高并发处理舛误

4.单 Reactor 单线程 1.职责旨趣：

①Select 是前边 I/O 复用模子先容的轨范网罗编程 API，不错达成应用设施通过一个阻拦对象监听多路取悦申请

②Reactor 对象通过 Select 监控客户端申请事件，收到事件后通过 Dispatch 进行分发

③如果是建立取悦申请事件，则由 Acceptor 通过 Accept 处理取悦申请，然后创建一个 Handler 对象处理取悦完成后的后续业务处理

④如果不是建立取悦事件，则 Reactor 会分发调用取悦对应的 Handler 来反馈

⑤Handler 会完成 Read→业务处理→Send 的无缺业务历程

2.优点：

模子粗陋，莫得多线程、程度通讯、竞争的问题，一王人都在一个线程中完成

3.流弊：

①性能问题，惟有一个线程，无法十足发达多核 CPU 的性能。

②可靠性问题，线程不测拒绝，简略插足死轮回，会导致通盘这个词系统通讯模块不可用，不可承袭和处理外部音书，变成节点故障

③作事器端用一个线程通过多路复用料理通盘的 IO 操作（包括取悦，读、写等），编码粗陋，明晰明了，然则如果客户端取悦数目较多时，当对应多个读时，如故会出现阻拦表象，当这种情况发生时将无法因循高并发的场景。

4.应用场景：

客户端的数目有限，业务处理相配快速(比如 Redis在业务处理的时分复杂度 O(1) 的情况)

 

图片

5.单Reactor多线程 1.职责旨趣：

①Reactor 对象通过select 监控客户端申请事件， 收到事件后，通过dispatch进行分发

②如果是建立取悦申请， 则由Acceptor 通过accept 处理取悦申请， 然后创建一个Handler对象处理完成取悦后的多样事件

③如果不是取悦申请，则由Reactor分发调用取悦对应的handler 来处理

④handler 只讲求反馈事件，不作念具体的业务处理， 通过read 读取数据后，会分发给后头的worker线程池的某个线程处理业务。

⑤worker 线程池会分配寂寥线程完成果真的业务，并将效果复返给handler，handler收到反馈后，通过send 将效果复返给client.

2.优点：

不错充分的诈欺多核cpu 的处理才略

3.流弊：

多线程数据分享和探望比拟复杂，Reactor处理通盘的事件的监听和反馈，在单线程运行时，在高并发场景容易出现性能瓶颈.

 

图片

6.主从 Reactor 多线程 1.职责旨趣：

①Reactor干线程 MainReactor 对象通过select 监听取悦事件， 收到事件后，通过Acceptor 处理取悦事件

②当 Acceptor  处理取悦事件后，MainReactor 将取悦分配给SubReactor

③subReactor 将取悦加入到取悦部队进行监听，并创建handler进行多样事件处理

④当有新事件发生时， subreactor 就会调用对应的handler处理

⑤handler 通过read 读取数据，分发给后头的worker 线程处理

⑥worker 线程池分配寂寥的worker 线程进行业务处理，并复返效果

⑦handler 收到反馈的效果后，再通过send 将效果复返给client

⑧Reactor 干线程不错对应多个Reactor 子线程， 即MainRecator 不错相关多个SubReactor

 

图片

三．Netty线程模子 1.职责旨趣

Netty综合出两组线程池 BossGroup 挑升讲求承袭客户端的取悦， WorkerGroup 挑升讲求网罗的读写

BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup

NioEventLoopGroup 格外于一个事件轮回组， 这个组中含有多个事件轮回 ，每一个事件轮回是 NioEventLoop

NioEventLoop 暗意一个束缚轮回的履行处理任务的线程， 每个NioEventLoop 都有一个selector ， 用于监听绑定在该通谈上的socket的网罗通讯

NioEventLoopGroup 不错有多个线程， 即不错含有多个NioEventLoop

每个Boss NioEventLoop 轮回履行的门径有3步

轮询accept 事件

处理accept 事件 ， 与client端建立取悦 ， 生成NioScocketChannel ， 并将其注册到某个worker NIOEventLoop 上的 selector 上

处理任务部队的任务 ， 即 runAllTasks

每个 Worker NIOEventLoop 轮回履行的门径

轮询read， write 事件

处理i/o事件， 即read ， write 事件，在对应NioScocketChannel 处理

处理任务部队的任务 ， 即 runAllTasks

每个Worker NIOEventLoop  处理业务时，会使用pipeline(管谈)， pipeline 中包含了boss group上NioEventLoop注册到worker 的selector 的channel ， 即通过pipeline 不错获取到对应通谈， 管谈中爱护了许多的处理器

 

图片

四．Netty初学 1.引入java包

(JDK 5（Netty 3.x）或 6（Netty 4.x）)
<dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.20.Final</version>
</dependency>

2.hello world 编写

初学的编写一共需要4个类

netty server

netty server handler

netty client

netty client handler

2.1.netty server 端编写

图片

package com.zpb.netty.netty.helloWorld;

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.NioEventLoop;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @dec : netty初学
 * @Date: 2019/11/24
 * @Auther: pengbo.zhao
 * @version: 1.0
 * @demand:
 *
 *    {@link #main(String[] args)}
 *
 */
public class NettyServer {

        public static void main(String[] args) throws  Exception{

        //1.创建BossGroup 和 WorkerGroup
        //1.1 创建2个线程组
        //bossGroup只处理取悦申请
        //workerGroup 处理客户端的业务逻辑
        //2个都是无尽轮回
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        //2.创建作事端的启动对象，不错为作事端启动确立一些作事参数
        ServerBootstrap bootStrap = new ServerBootstrap();

        //2.1使用链式编程来确立作事参数
        bootStrap.group(bossGroup，workerGroup)                          //竖立2个线程组
                .channel(NioServerSocketChannel.class)                 //使用NioServerSocketChannel当作作事器的通谈
                .option(ChannelOption.SO_BACKLOG，128)            //竖立线程恭候的取悦个数
                .childOption(ChannelOption.SO_KEEPALIVE，Boolean.TRUE) //竖立保抓行为取悦气象
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    //给PipeLine竖立处理器
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        //通过socketChannel得到pipeLine，然后向pipeLine中添加处理的handle
                        socketChannel.pipeline().addLast(new NettyServerHandle());
                    }
                }); //给workerGroup 的EventLoop对应的管谈竖立处理器(不错自界说/也可使用netty的)
        System.err.println('server is ready......');

        //启动作事器，并绑定1个端口且同步生成一个ChannelFuture 对象
        ChannelFuture channelFuture = bootStrap.bind(8888).sync();

        //对关闭通谈进行监听(netty异步模子)
        //当通谈进行关闭时，才会触发这个关闭动作
        channelFuture.channel().closeFuture().sync();

    }
}

图片

2.2.netty server handler编写

图片

package com.zpb.netty.netty.helloWorld;

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;

/**
 * @dec :
 * @Date: 2019/11/24
 * @Auther: pengbo.zhao
 * @version: 1.0
 * @demand:
 */
public class NettyServerHandle extends ChannelInboundHandlerAdapter {
    /**
     * 读取数据
     *
     * @param: 1.ChannelHandlerContext ctx:高下文对象， 含有 管谈 pipeline ， 通谈 channel， 地址
     * @param: 2. Object msg: 即是客户端发送的数据 默许 Object
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx， Object msg) throws Exception {
        System.err.println('作事器读取线程 '   Thread.currentThread().getName());
        System.out.println('server ctx ='   ctx);
        System.out.println('望望 channel 和 pipeline 的关系');

        Channel channel = ctx.channel();
        ChannelPipeline pipeline = ctx.pipeline(); //践诺是一个双向取悦， 出站入站

        //将 msg 转成一个 ByteBuf，ByteBuf 是 Netty 提供的，不是 NIO 的 ByteBuffer.
        ByteBuf buf = (ByteBuf) msg;
        System.out.println('客户端发送音书是:'   buf.toString(CharsetUtil.UTF_8));
        System.out.println('客户端地址:'   channel.remoteAddress());
    }

    /**
     * 读取数据完成后
     *
     * @param:
     * @return:
     * @auther:
     * @date:
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //writeAndFlush 是 write   flush
        //将数据写入到缓存，并刷新
        //一般讲，咱们对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer('hello， 客户端~(>^ω^<)喵'， CharsetUtil.UTF_8));
    }

    //处理格外， 一般是需要关闭通谈
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx， Throwable cause) throws Exception {
        ctx.close();
    }
}

图片

2.3.netty client端编写

图片

package com.zpb.netty.netty.helloWorld;

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;


/**
 * @dec :
 * @Date: 2019/11/24
 * @Auther: pengbo.zhao
 * @version: 1.0
 * @demand:
 */
public class NettyClient {

    public static void main(String[] args) throws Exception {

        //1.客户端界说一个轮回事件组
        EventLoopGroup group = new NioEventLoopGroup();

        try {

            //2.创建客户端启动对象
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)                      //竖立线程组
                    .channel(NioSocketChannel.class)   //竖立客户端通谈达成类
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyClientHandle());
                        }
                    });
            System.err.println('client is ready......');

            //3.启动客户端去取悦作事端
            ChannelFuture channelFuture = bootstrap.connect('127.0.0.1'， 8888).sync();

            //4.竖立通谈关闭监听(当监听到通谈关闭时，关闭client)
            channelFuture.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

图片

2.4.netty client handler端编写

图片

package com.zpb.netty.netty.helloWorld;

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;

/**
 * @dec :
 * @Date: 2019/11/24
 * @Auther: pengbo.zhao
 * @version: 1.0
 * @demand:
 */
public class NettyClientHandle extends ChannelInboundHandlerAdapter{

    //如果client 端作事启动完成后
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

        System.err.println('client ' ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer('hello，netty server...'，CharsetUtil.UTF_8));
    }

    //当通谈有读事件时
    @Override
    public void channelRead(ChannelHandlerContext ctx， Object msg) throws Exception {

        ByteBuf byteBuf = (ByteBuf) msg;
        System.err.println('作事器端恢复音书：' byteBuf.toString(CharsetUtil.UTF_8));
        System.err.println('作事器端地址是：' ctx.channel().remoteAddress());
    }

    //当通谈有格外时

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

图片

五．Netty三种任务部队的使用

当咱们在处理的handle中如果出现了阻拦的情况，简略处理业务逻辑比拟耗时，咱们不可让设施处于阻拦，

当有客户端申请时，咱们想让设施定时的去履行业务逻辑，

当需要对一些用户需要进行推送行为时，笔据用户瑰丽，找到对应的 Channel 援用，向该用户推送特定音书时

不错弃取以下三种任务部队：

1.提交到execute(Runnable command)中时

ctx.channel().eventLoop().execute(new Runnable() { })

业务逻辑交给线程去向理，线程不会阻拦在这里，而是胜利复返，直到特别据才复返给客户端，如果有多个线程runnable需要处理，那么只可等上一个处理完才会处理下一个，(假如第1个任务需要10S，第2个需要20s，履行完共需30S)

2.提交到 scheduledTaskQueue中

图片

schedule(Runnable command， long delay， TimeUnit unit)

①Runnable command：履行业务逻辑处理的线程

② long delay：定时时长

③TimeUnit unit：定时类型

业务逻辑交给定时线程去向理。

图片

欧美伦理片a在线观看

3.通过传输的内容的瑰丽插入系列

在解码客户端发送的内容中，读取到客户端的特殊瑰丽，诈欺这个瑰丽来进行推送音书处理，这个在粘包、拆包中进行讲解

本站仅提供存储作事，通盘内容均由用户发布，如发现存害或侵权内容，请点击举报。