学Netty前,仍是要先把JavaNIO编程模型掌握好

2022年05月14日 阅读数:7
这篇文章主要向大家介绍学Netty前,仍是要先把JavaNIO编程模型掌握好,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

1、Java NIO 基本介绍

Java NIO 全称 java non-blocking IO,是指 JDK 提供的新 API。从 JDK1.4 开始,Java 提供了一系列改进的输入/输出的新特性,被统称为 NIO(即 New IO),是同步非阻塞的java

NIO 相关类都被放在 java.nio 包及子包下,而且对原 java.io 包中的不少类进行改写。编程

NIO是面向缓冲区 ,或者面向 快 编程的。数据读取到一个它稍后处理的缓冲区,须要时可在缓冲区中先后移动,这就增长了处理过程当中的灵活性,使用它能够提供非阻塞式的高伸缩性网络api

  Java NIO的非阻塞模式,使一个线程从某通道发送请求或者读取数据,可是它仅能获得目前可用的数据,若是目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,因此直至数据变的能够读取以前,该线程能够继续作其余的事情。非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不须要等待它彻底写入,这个线程同时能够去作别的事情。数组

  通俗理解:NIO是能够作到用一个线程来处理多个操做的。假设有10000个请求过来,根据实际状况,能够分配50或者100个线程来处理。不像以前的阻塞IO那样,非得分配10000个。缓存

  HTTP2.0使用了多路复用的技术,作到同一个链接并发处理多个请求,并且并发请求的数量比HTTP1.1大了好几个数量级。网络

2、NIO和BIO的比较

  1. BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比例 I/O 高不少
  2. BIO 是阻塞的,NIO 则是非阻塞的
  3. BIO基于字节流和字符流进行操做,而 NIO 基于Channel(通道)和 Buffer(缓冲区)进行操做,数据老是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(好比:链接请求,数据到达等),所以使用单个线程就能够监听多个客户端通道

3、NIO三大核心

  下图描述了 Buffer,Channel,Selector三者的关系多线程

  • 每一个channel 都会对应一个Buffer
  • Selector 对应一个线程, 一个线程对应多个channel(链接)
  • 该图反应了有三个channel 注册到 该selector //程序
  • 程序切换到哪一个channel 是有事件决定的, Event 就是一个重要的概念
  • Selector 会根据不一样的事件,在各个通道上切换
  • Buffer 就是一个内存块 , 底层是有一个数组
  • 数据的读取写入是经过Buffer, 这个和BIO , BIO 中要么是输入流,或者是输出流, 不能双向,可是NIO的Buffer 是能够读也能够写, 须要 flip 方法切换channel 是双向的, 能够返回底层操做系统的状况, 好比Linux , 底层的操做系统
  • 通道就是双向的.

3.1缓冲区Buffer架构

基本介绍并发

  缓冲区(Buffer):缓冲区本质上是一个能够读写数据的内存块,能够理解成是一个容器对象(含数组),该对象提供了一组方法,能够更轻松地使用内存块,,缓冲区对象内置了一些机制,可以跟踪和记录缓冲区的状态变化状况。Channel 提供从文件、网络读取数据的渠道,可是读取或写入的数据都必须经由 Buffer,app

Buffer 类及其子类

一、在 NIO 中,Buffer 是一个顶层父类,它是一个抽象类, 类的层级关系图:

经过名称也比较直观的能看出每一个具体Buffer的做用。

二、Buffer类定义了全部的缓冲区都具备的四个属性来提供关于其所包含的数据元素的信息:

private int mark = -1;
private int position = 0;
private int limit;
    private int capacity;    

三、Buffer类相关方法一览

public abstract class Buffer {
//JDK1.4时,引入的api
public final int capacity( )//返回此缓冲区的容量
public final int position( )//返回此缓冲区的位置
public final Buffer position (int newPositio)//设置此缓冲区的位置
public final int limit( )//返回此缓冲区的限制
public final Buffer limit (int newLimit)//设置此缓冲区的限制
public final Buffer mark( )//在此缓冲区的位置设置标记
public final Buffer reset( )//将此缓冲区的位置重置为之前标记的位置
public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态,可是数据并无真正擦除, 后面操做会覆盖
public final Buffer flip( )//反转此缓冲区
public final Buffer rewind( )//重绕此缓冲区
public final int remaining( )//返回当前位置与限制之间的元素数
public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素
public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区
//JDK1.6时引入的api
public abstract boolean hasArray();//告知此缓冲区是否具备可访问的底层实现数组
public abstract Object array();//返回此缓冲区的底层实现数组
public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
}

四、ByteBuffer

从前面能够看出对于 Java 中的基本数据类型(boolean除外),都有一个 Buffer 类型与之相对应,最经常使用的天然是ByteBuffer 类(二进制数据),该类的主要方法以下

public abstract class ByteBuffer {
//缓冲区建立相关api
public static ByteBuffer allocateDirect(int capacity)//建立直接缓冲区
public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量
public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用
//构造初始化位置offset和上界length的缓冲区
public static ByteBuffer wrap(byte[] array,int offset, int length)
//缓存区存取相关API
public abstract byte get( );//从当前位置position上get,get以后,position会自动+1
public abstract byte get (int index);//从绝对位置get
public abstract ByteBuffer put (byte b);//从当前位置上添加,put以后,position会自动+1
public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
 }

3.2 通道Channel

基本介绍

一、NIO的通道相似于流,但有些区别以下:

  1. 通道能够同时进行读写,而流只能读或者只能写
  2. 通道能够实现异步读写数据
  3. 通道能够从缓冲读数据,也能够写数据到缓冲

二、BIO 中的 stream 是单向的,例如 FileInputStream 对象只能进行读取数据的操做,而 NIO 中的通道(Channel)是双向的,能够读操做,也能够写操做。

三、Channel在NIO中是一个接口public interface Channel extends Closeable{}

四、经常使用的 Channel 类有:FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 相似 ServerSocket , SocketChannel 相似 Socket】

五、FileChannel 用于文件的数据读写,DatagramChannel 用于 UDP 的数据读写,ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

FileChannel 类

FileChannel主要用来对本地文件进行 IO 操做,常见的方法有

public int read(ByteBuffer dst) ,从通道读取数据并放到缓冲区中
public int write(ByteBuffer src) ,把缓冲区的数据写到通道中
public long transferFrom(ReadableByteChannel src, long position, long count),从目标通道中复制数据到当前通道
public long transferTo(long position, long count, WritableByteChannel target),把数据从当前通道复制给目标通道

实例1-本地文件写数据

经过前面介绍的内容完成一些简单的NIO文件操做,代码以下:

package com.dpb.netty.nio;

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

/**
 * @program: netty4demo
 * @description:
 * @author: 波波烤鸭
 * @create: 2019-12-28 11:37
 */
public class NioChannel01 {

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

        String str = "hello,bobokaoya";
//建立一个输出流->channel
        FileOutputStream fileOutputStream = new FileOutputStream("c:\\tools\\netty.txt");

//经过 fileOutputStream 获取 对应的 FileChannel
//这个 fileChannel 真实 类型是  FileChannelImpl
        FileChannel fileChannel = fileOutputStream.getChannel();
//建立一个缓冲区 ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024)
//将 str 放入 byteBuffer
        byteBuffer.put(str.getBytes());
//对byteBuffer 进行flip
        byteBuffer.flip();
//将byteBuffer 数据写入到 fileChannel
        fileChannel.write(byteBuffer);
        fileOutputStream.close();
    }
}

实例2-本地文件读数据

package com.dpb.netty.nio;

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

/**
 * @program: netty4demo
 * @description:
 * @author: 波波烤鸭
 * @create: 2019-12-28 11:41
 */
public class NioChannel02 {
public static void main(String[] args) throws Exception {

//建立文件的输入流
        File file = new File("c:\\tools\\netty.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

//经过fileInputStream 获取对应的FileChannel -> 实际类型  FileChannelImpl
        FileChannel fileChannel = fileInputStream.getChannel();

//建立缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());

//将 通道的数据读入到Buffer
        fileChannel.read(byteBuffer);

//将byteBuffer 的 字节数据 转成String
        System.out.println(new String(byteBuffer.array()));
        fileInputStream.close();
    }
}

实例3-使用一个Buffer完成文件读取

package com.dpb.netty.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
 * @program: netty4demo
 * @description:
 * @author: 波波烤鸭
 * @create: 2019-12-28 11:44
 */
public class NioChannel03 {
public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("1.txt");
        FileChannel fileChannel01 = fileInputStream.getChannel();
        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        FileChannel fileChannel02 = fileOutputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(512);
while (true) { //循环读取
//这里有一个重要的操做,必定不要忘了
/*
             public final Buffer clear() {
                position = 0;
                limit = capacity;
                mark = -1;
                return this;
            }
             */
            byteBuffer.clear(); //清空buffer
int read = fileChannel01.read(byteBuffer);
            System.out.println("read =" + read);
if(read == -1) { //表示读完
break;
            }
//将buffer 中的数据写入到 fileChannel02 -- 2.txt
            byteBuffer.flip();
            fileChannel02.write(byteBuffer);
        }

//关闭相关的流
        fileInputStream.close();
        fileOutputStream.close();
    }
}

实例4-拷贝文件transferFrom 方法

接下来咱们同transferFrom方法来实现一个文件的复制操做。

package com.dpb.netty.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;

/**
 * @program: netty4demo
 * @description:
 * @author: 波波烤鸭
 * @create: 2019-12-28 11:49
 */
public class NioChannel04 {
public static void main(String[] args)  throws Exception {

//建立相关流
        FileInputStream fileInputStream = new FileInputStream("c:\\tools\\a1.jpg");
        FileOutputStream fileOutputStream = new FileOutputStream("c:\\tools\\a2.jpg");
//获取各个流对应的filechannel
        FileChannel sourceCh = fileInputStream.getChannel();
        FileChannel destCh = fileOutputStream.getChannel();
//使用transferForm完成拷贝
        destCh.transferFrom(sourceCh,0,sourceCh.size());
//关闭相关通道和流
        sourceCh.close();
        destCh.close();
        fileInputStream.close();
        fileOutputStream.close();
    }
}

关于Buffer 和 Channel的注意事项和细节

ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型,get就应该使用相应的数据类型来取出,不然可能有 BufferUnderflowException 异常。

能够将一个普通Buffer 转成只读Buffer [举例说明]

NIO 还提供了 MappedByteBuffer, 可让文件直接在内存(堆外的内存)中进行修改, 而如何同步到文件由NIO 来完成.

前面咱们讲的读写操做,都是经过一个Buffer 完成的,NIO 还支持 经过多个Buffer (即 Buffer 数组) 完成读写操做,即 Scattering 和 Gathering

3.3 选择器Selector

基本介绍

Java 的 NIO,用非阻塞的 IO 方式。能够用一个线程,处理多个的客户端链接,就会使用到Selector(选择器)

  Selector 可以检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式能够注册到同一个Selector),若是有事件发生,便获取事件而后针对每一个事件进行相应的处理。这样就能够只用一个单线程去管理多个通道,也就是管理多个链接和请求。

只有在 链接/通道 真正有读写事件发生时,才会进行读写,就大大地减小了系统开销,而且没必要为每一个链接都建立一个线程,不用去维护多个线程

避免了多线程之间的上下文切换致使的开销

特色再说明:

  1. Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器,也叫多路复用器),能够同时并发处理成百上千个客户端链接。
  2. 当线程从某客户端 Socket 通道进行读写数据时,若没有数据可用时,该线程能够进行其余任务。
  3. 线程一般将非阻塞 IO 的空闲时间用于在其余通道上执行 IO 操做,因此单独的线程能够管理多个输入和输出通道。
  4. 因为读写操做都是非阻塞的,这就能够充分提高 IO 线程的运行效率,避免因为频繁 I/O 阻塞致使的线程挂起。
  5. 一个 I/O 线程能够并发处理 N 个客户端链接和读写操做,这从根本上解决了传统同步阻塞 I/O 一链接一线程模型,架构的性能、弹性伸缩能力和可靠性都获得了极大的提高。

Selector类相关方法

Selector 类是一个抽象类, 经常使用方法和说明以下:

public abstract class Selector implements Closeable { 
public static Selector open();//获得一个选择器对象
//监控全部注册的通道,当其中有 IO 操做能够进行时,将对应的 SelectionKey 加入到内部集合中并返回,参数用来设置超时时间
public int select(long timeout);
public Set<SelectionKey> selectedKeys();//从内部集合中获得全部的 SelectionKey  
}

注意事项

NIO中的 ServerSocketChannel功能相似ServerSocket,SocketChannel功能相似Socket

selector 相关方法说明

selector.select()//阻塞
selector.select(1000);//阻塞1000毫秒,在1000毫秒后返回
selector.wakeup();//唤醒selector
selector.selectNow();//不阻塞,立马返还