Netty介绍及相关基础知识

最新推荐文章于 2024-08-05 16:01:27 发布

zdwhong

最新推荐文章于 2024-08-05 16:01:27 发布

阅读量459

点赞数

分类专栏： Netty 文章标签： Netty NIO AIO BIO Java

本文链接：https://blog.csdn.net/zengdongwen/article/details/96306619

版权

Netty 专栏收录该内容

6 篇文章 3 订阅

订阅专栏

1、Netty介绍

1.1 简介

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。

也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP的socket服务开发。

“快速”和“简单”并不会产生维护性或性能上的问题。Netty 是一个吸收了多种协议（包括FTP、SMTP、HTTP等各种二进制文本协议）的实现经验，并经过相当精心设计的项目。最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。

1.2 优点

Netty提供了简单易用的API

基于事件驱动的编程方式来编写网络通信程序

更高的吞吐量

学习难度低

1.3 应用场景

JavaEE： Dubbo

大数据：Apache Storm（Supervisor worker进程间的通信也是基于Netty来实现的）

2、BIO、NIO、AIO介绍与区别

2.1 阻塞与非阻塞

其实这里说的阻塞不是针对网络通讯模型而言，而是针对磁盘文件读写IO操作来说的。

主要指的是访问IO的线程是否会阻塞（或者说是等待）

线程访问资源，该资源是否准备就绪的一种处理方式。

2.2 同步和异步

主要是指的数据的请求方式，同步和异步是指访问数据的一种机制

2.3 BIO

同步阻塞IO，Block IO，IO操作时会阻塞线程，并发处理能力低。

我们熟知的Socket编程就是BIO，一个socket连接一个处理线程（这个线程负责这个Socket连接的一系列数据传输操作）。

阻塞的原因在于：操作系统允许的线程数量是有限的，多个socket申请与服务端建立连接时，服务端不能提供相应数量的处理线程，没有分配到处理线程的连接就会阻塞等待或被拒绝。

BIO其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， 
ServerSocket接收到了一个连接请求就创建一个Socket和一个线程去跟那个Socket进行通讯。

接着客户端和服务端就进行阻塞式的通信，客户端发送一个请求，服务端Socket进行处理后返回响应。
在响应返回前，客户端那边就阻塞等待，什么事情也做不了.

这种方式的缺点：每次一个客户端接入，都需要在服务端创建一个线程来服务这个客户端。
这样大量客户端来的时候，就会造成服务端的线程数量可能达到了几千甚至几万，这样就可能会造成服务端过载过高，最后崩溃死掉。

BIO模型图：

2.4 NIO

同步非阻塞IO，None-Block IO

NIO是对BIO的改进，基于Reactor模型。我们知道，一个socket连接只有在特定时候才会发生数据传输IO操作，大部分时间这个“数据通道”是空闲的，但还是占用着线程。NIO作出的改进就是“一个请求一个线程”，在连接到服务端的众多socket中，只有需要进行IO操作的才能获取服务端的处理线程进行IO。这样就不会因为线程不够用而限制了socket的接入。

NIO其实相当于就是一个线程处理大量的客户端的请求，通过一个线程轮询大量的channel，
每次就获取一批有事件的channel，然后对每个请求启动一个线程处理即可。

这里的核心就是非阻塞，就那个selector一个线程就可以不停轮询channel，所有客户端请求都不会阻塞，
直接就会进来，大不了就是等待一下排着队而已。

这里面优化BIO的核心就是，一个客户端并不是时时刻刻都有数据进行交互，没有必要死耗着一个线程不放，
所以客户端选择了让线程歇一歇，只有客户端有相应的操作的时候才发起通知，创建一个线程来处理请求。

Reactor模型:

NIO模型图：

2.5 AIO（NIO 2.0）

异步非阻塞IO，基于Proactor模型实现。

这种IO模型是由操作系统先完成了客户端请求处理再通知服务器去启动线程进行处理。AIO也称NIO2.0，在JDK7开始支持。

每个连接发送过来的请求，都会绑定一个Buffer，然后通知操作系统去完成异步的读，这个时间你就可以去做其他的事情
等到操作系统完成读之后，就会调用你的接口，给你操作系统异步读完的数据。这个时候你就可以拿到数据进行处理，将数据往回写

在往回写的过程，同样是给操作系统一个Buffer，让操作系统去完成写，写完了来通知你。
这俩个过程都有buffer存在，数据都是通过buffer来完成读写。

这里面的主要的区别在于将数据写入到缓冲区后，就不去管它，剩下的去交给操作系统去完成。
操作系统写回数据也是一样，写到Buffer里面，写完后通知客户端来进行读取数据。

AIO：模型图

2.6 为什么说BIO是同步阻塞的呢？

其实这里说的不是针对网络通讯模型而言，而是针对磁盘文件读写IO操作来说的。因为用BIO的流读写文件，例如FileInputStrem，是说你发起个IO请求直接hang死，卡在那里，必须等着搞完了这次IO才能返回。

2.7 为什么说NIO为啥是同步非阻塞？

因为无论多少客户端都可以接入服务端，客户端接入并不会耗费一个线程，只会创建一个连接然后注册到selector上去，这样你就可以去干其他你想干的其他事情了

一个selector线程不断的轮询所有的socket连接，发现有事件了就通知你，然后你就启动一个线程处理一个请求即可，这个过程的话就是非阻塞的。

但是这个处理的过程中，你还是要先读取数据，处理，再返回的，这是个同步的过程。

2.8 为什么说AIO是异步非阻塞？

通过AIO发起个文件IO操作之后，你立马就返回可以干别的事儿了，接下来你也不用管了，操作系统自己干完了IO之后，告诉你说ok了。当你基于AIO的api去读写文件时，当你发起一个请求之后，剩下的事情就是交给了操作系统

当读写完成后，操作系统会来回调你的接口，告诉你操作完成

在这期间不需要等待，也不需要去轮询判断操作系统完成的状态，你可以去干其他的事情。

同步就是自己还得主动去轮询操作系统，异步就是操作系统反过来通知你。所以来说， AIO就是异步非阻塞的。

3、Netty Reactor模型 - 单线程模型、多线程模型、主从多线程模型介绍

3.1 单线程模型

用户发起IO请求到Reactor线程

Ractor线程将用户的IO请求放入到通道，然后再进行后续处理

处理完成后，Reactor线程重新获得控制权，继续其他客户端的处理

这种模型一个时间点只有一个任务在执行，这个任务执行完了，再去执行下一个任务。
1.	但单线程的Reactor模型每一个用户事件都在一个线程中执行：
2.	性能有极限，不能处理成百上千的事件
3.	当负荷达到一定程度时，性能将会下降
4.	某一个事件处理器发生故障，不能继续处理其他事件

3.2 Reactor多线程模型

Reactor多线程模型是由一组NIO线程来处理IO操作（之前是单个线程），所以在请求处理上会比上一种模型效率更高，可以处理更多的客户端请求。

这种模式使用多个线程执行多个任务，任务可以同时执行。

但是如果并发仍然很大，Reactor仍然无法处理大量的客户端请求

3.3 Reactor主从多线程模型

这种线程模型是Netty推荐使用的线程模型

这种模型适用于高并发场景，一组线程池接收请求，一组线程池处理IO。

4、NIO核心组件详细

学习NIO先来搞清楚一些相关的概念，NIO通讯有哪些相关组件，对应的作用都是什么，之间有哪些联系？

4.1 多路复用机制实现Selector

首先我们来了解下传统的Socket网络通讯模型：

为什么传统的socket不支持海量连接？

每次一个客户端接入，都是要在服务端创建一个线程来服务这个客户端的

这会导致大量的客户端的时候，服务端的线程数量可能达到几千甚至几万，几十万，这会导致服务器端程序负载过高，不堪重负，最终系统崩溃死掉。

接着来看下NIO是如何基于Selector实现多路复用机制支持的海量连接。

NIO原理图：

多路复用机制是如何支持海量连接？

NIO的线程模型对Socket发起的连接不需要每个都创建一个线程，完全可以使用一个Selector来多路复用监听N多个Channel是否有请求，该请求是对应的连接请求，还是发送数据的请求

这里面是基于操作系统底层的Select通知机制的，一个Selector不断的轮询多个Channel，这样避免了创建多个线程

只有当某个Channel有对应的请求的时候才会创建线程，可能说1000个请求，只有100个请求是有数据交互的

这个时候可能server端就提供10个线程就能够处理这些请求。这样的话就可以避免了创建大量的线程。

4.2 NIO如何通过Buffer来缓冲数据的

NIO中的Buffer是个什么东西？

学习NIO，首当其冲就是要了解所谓的Buffer缓冲区，这个东西是NIO里比较核心的一个部分

一般来说，如果你要通过NIO写数据到文件或者网络，或者是从文件和网络读取数据出来此时就需要通过Buffer缓冲区来进行。Buffer的使用一般有如下几个步骤：

写入数据到Buffer，调用flip()方法，从Buffer中读取数据，调用clear()方法或者compact()方法。

Buffer中对应的Position， Mark， Capacity，Limit都啥？

capacity：缓冲区容量的大小，就是里面包含的数据大小。
limit：对buffer缓冲区使用的一个限制，从这个index开始就不能读取数据了。
position：代表着数组中可以开始读写的index，不能大于limit。
mark：是类似路标的东西，在某个position的时候，设置一下mark，此时就可以设置一个标记

后续调用reset()方法可以把position复位到当时设置的那个mark上。去把position或limit调整为小于mark的值时，就丢弃这个mark

如果使用的是Direct模式创建的Buffer的话，就会减少中间缓冲，直接使用DirectorBuffer来进行数据的存储。

如何通过Channel和FileChannel读取Buffer数据写入磁盘的？

NIO中，Channel是什么？

Channel是NIO中的数据通道，类似流，但是又有些不同

Channel既可从中读取数据，又可以写数据到通道中，但是流的读写通常是单向的。

Channel可以异步的读写。Channel中的数据总是要先读到一个Buffer中，或者从缓冲区中将数据写到通道中。

FileChannel的作用是什么？

Buffer有不同的类型，同样Channel也有好几个类型。

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

这些通道涵盖了UDP 和 TCP 网络IO，以及文件IO。而FileChannel就是文件IO对应的管道，在读取文件的时候会用到这个管道

下面给一个简单的NIO实现读取文件的Demo代码

package test;

import java.io.File;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * Create By zdw on 2019/7/17
 * 简单的NIO实现读取文件的Demo代码
 */
public class FileChannelDemo1 {
    public static void main(String[] args) throws Exception {
        //创建一个传统的文件输出流
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\word\\hello.txt");
        //通过文件输出流获取到对应FileChannel，以NIO的方式写文件
        FileChannel fileChannel = fileOutputStream.getChannel();
        //将数据写道buffer种
        ByteBuffer buffer = ByteBuffer.wrap("Hello NIO".getBytes());
        //通过fileChannel把buffer中的数据写到输出流中，持久化到磁盘
        fileChannel.write(buffer);
        //关闭通道
        fileChannel.close();
        fileOutputStream.close();
    }
}

5、NIOServer端和Client端代码案例

5.1 NIO通讯Client端

package nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * Create By zdw on 2019/7/17
 */
public class NIOClient {

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            new Worker().start();
        }
    }

    static class Worker extends Thread{
        @Override
        public void run() {
            SocketChannel socketChannel=null;
            Selector selector = null;
            try {
                //SocketChannel，一看底层就是封装了一个Socket
                socketChannel = SocketChannel.open();//SocketChannel是连接到底层的Socket网络
                //数据通道就是负责基于网络读写数据的

                //将Channel设置为非阻塞的 NIO就是支持非阻塞的
                socketChannel.configureBlocking(false);
                //后台一定是tcp三次握手建立网络连接
                socketChannel.connect(new InetSocketAddress("localhost",9000));

                selector = Selector.open();
                //监听Connect这个行为
                socketChannel.register(selector, SelectionKey.OP_CONNECT);

                while(true){
                    //selector多路复用机制的实现  循环去遍历各个注册的Channel
                    selector.select();
                    Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();
                    while (keysIterator.hasNext()){
                        SelectionKey key = keysIterator.next();
                        keysIterator.remove();
                        //如果发现返回的是一个可连接的消息 走到下面去接收数据
                        if(key.isConnectable()){
                            socketChannel = (SocketChannel) key.channel();
                            if(socketChannel.isConnectionPending()){
                                socketChannel.finishConnect();
                                // 接下来对这个SocketChannel感兴趣的就是人家server给你发送过来的数据了
                                // READ事件，就是可以读数据的事件
                                // 一旦建立连接成功了以后，此时就可以给server发送一个请求了
                                ByteBuffer buffer = ByteBuffer.allocate(1024);
                                buffer.put("Hello 你好啊".getBytes());
                                buffer.flip();
                                socketChannel.write(buffer);
                            }
                            socketChannel.register(selector,SelectionKey.OP_READ);
                        }else if(key.isReadable()) {//这里的话就是服务器端返回了一条数据可以读了
                            socketChannel = (SocketChannel) key.channel();
                            //构建一个缓冲区
                            ByteBuffer buffer = ByteBuffer.allocate(1024);
                            //吧数据写进buffer，position推进到读取的字节数数字
                            int len = socketChannel.read(buffer);
                            if(len>0){
                                System.out.println("["+Thread.currentThread().getName()+"]收到响应："+new String(buffer.array(),0,len));
                                Thread.sleep(5000);
                                socketChannel.register(selector,SelectionKey.OP_WRITE);
                            }
                        }else if(key.isWritable()){
                            //构建一个缓冲区
                            ByteBuffer buffer = ByteBuffer.allocate(1024);
                            buffer.put("你好".getBytes());
                            buffer.flip();

                            socketChannel=(SocketChannel)key.channel();
                            socketChannel.write(buffer);
                            socketChannel.register(selector,SelectionKey.OP_READ);
                        }
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(socketChannel!=null){
                    try {
                        socketChannel.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(selector!=null){
                    try {
                        selector.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

5.2 NIOServer服务端

package nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * Create By zdw on 2019/7/17
 */
public class NIOServer {
    private static Selector selector;
    private static LinkedBlockingQueue<SelectionKey> requestQueue;
    private static ExecutorService threadPool;

    public static void main(String[] args) {
        init();
        listen();
    }

    private static void init(){
        ServerSocketChannel serverSocketChannel = null;
        try {
            selector = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();
            //将Channel设置为非阻塞的 NIO就是支持非阻塞的
            serverSocketChannel.configureBlocking(false);
            //ServerSocket，就是负责去跟各个客户端连接连接请求的
            serverSocketChannel.socket().bind(new InetSocketAddress(9000),100);

            //就是仅仅关注这个ServerSocketChannel接收到的TCP连接的请求
            serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
        }catch (Exception e){
            e.printStackTrace();
        }
        requestQueue = new LinkedBlockingQueue<SelectionKey>(500);

        threadPool = Executors.newFixedThreadPool(10);
        for(int i =0;i<10;i++){
            threadPool.submit(new Worker());
        }
    }

    private static void listen(){
        while (true){
            try {
                selector.select();
                Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();
                while (keysIterator.hasNext()){
                    //可以认为一个SelectionKey是代表了一个请求
                    SelectionKey selectionKey = keysIterator.next();
                    keysIterator.remove();
                    handleRequest(selectionKey);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    private static void handleRequest(SelectionKey selectionKey) throws Exception{
        //后台的线程池中的线程处理下面的代码逻辑
        SocketChannel channel = null;
        try {
            if(selectionKey.isAcceptable()){// 如果说这个Key是一个acceptable,也就是一个连接请求
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel)selectionKey.channel();
                //调用accept这个方法 就可以进行TCP三次握手了
                channel = serverSocketChannel.accept();
                //握手成功的话就可以获取到一个TCP连接好的SocketChannel
                channel.configureBlocking(false);
                //仅仅关注这个READ请求，就是人家发送数据过来的请求
                channel.register(selector,SelectionKey.OP_READ);
            }else if(selectionKey.isReadable()){//如果说这个key是readable，是个发送了数据过来的话，此时需要读取客户端发送过来的数据
                channel = (SocketChannel) selectionKey.channel();
                //创建缓冲区
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                //你读取到了多少个字节，此时buffer的position就会变成多少
                int len = channel.read(buffer);//通过底层的socket读取数据，写buffer中，position可能就会变成21之类的
                if(len>0){
                    // 准备读取刚写入的数据，就是将limit设置为当前position，将position设置为0，丢弃mark。一般就是先写入数据，接着准备从0开始读这段数据，就可以用flip
                    // position = 0，limit = 21，仅仅读取buffer中，0~21这段刚刚写入进去的数据
                    buffer.flip();
                    System.out.println("服务端接收请求："+new String(buffer.array(),0,len));
                    channel.register(selector,SelectionKey.OP_WRITE);
                }
            }else if(selectionKey.isWritable()){
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                buffer.put("收到".getBytes());
                buffer.flip();

                channel = (SocketChannel) selectionKey.channel();
                channel.write(buffer);
                channel.register(selector,SelectionKey.OP_READ);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(channel!=null){
                channel.close();
            }
        }
    }

    //创建一个线程任务来执行
    static class Worker implements Runnable{

        @Override
        public void run() {
            while (true){
                try {
                    SelectionKey selectionKey = requestQueue.take();
                    handleRequest(selectionKey);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

参考文献：

https://mp.weixin.qq.com/s/YIcXaH7AWLJbPjnTUwnlyQ

传智播客的netty资料

zdwhong

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Netty介绍及相关基础知识

1、Netty介绍1.1 简介Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应...
复制链接

扫一扫

专栏目录