NIO编程介绍

最新推荐文章于 2021-05-07 15:55:25 发布
最新推荐文章于 2021-05-07 15:55:25 发布
阅读量287 收藏
点赞数
分类专栏： Netty编程 文章标签： NIO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzx4959/article/details/84558002
版权

NIO称为Non-block IO，即非阻塞IO。IO（BIO）和NIO的本质区别就是阻塞和非阻塞的区别。

  • 阻塞：应用程序在获取网络数据的时候，如果网络传输数据很慢，那么程序就一直等着，直到传输完毕为止。
  • 非阻塞：应用程序直接可以获取已经准备就绪好的数据，无需等待。

IO为同步阻塞的形式，NIO为同步非阻塞的形式。NIO并没有实现异步，在JDK1.7之后，升级了NIO库包，支持异步非阻塞通信模型即NIO2.0（AIO）。同步和异步：同步和异步一般是面向操作系统与应用程序对IO操作的层面上来区别的。

  • 同步：应用程序会直接参与IO读写操作，并且我们的应用程序会直接阻塞到某一个方法上，直到数据准备就绪；或者采用轮询的策略实时检查数据的就绪状态，如果就绪则获取数据。
  • 异步：所有的IO读写操作交给操作系统处理，与我们的应用程序没有直接关系，我们程序不需要关心IO读写，当操作系统完成了IO读写操作时，会给我们应用程序发送通知，我们的应用程序直接拿走数据即可。

同步指的是我们Server服务器端的执行方式，阻塞指的是具体的实现技术，接收数据的方式、状态。（IO、NIO）

NIO的基本概念：

  • Buffer（缓冲区）
  • Channel（管道、通道）
  • Selector（选择器、多路复用器）

NIO的本质就是避免原始的TCP建立连接使用3次握手的操作，减少连接的开销。

一.Buffer

Buffer是一个对象，它包含了一些要写入或者要读取的数据。在NIO类库中加入Buffer对象，体现了新库与原IO的一个重要的区别。在面向流的IO中，可以将数据直接写入或读取到Stream对象中。在NIO库中，所有读写数据操作都是用缓冲区处理的，缓冲区实质上是一个数组，通常它是一个字节数组（BufferByte），也可以使用其他类型的数组。这个数组为缓冲区提供了数据的访问读写等操作，如位置、容量、上限等。

在实际中，我们最常用的Buffer类型是ByteBuffer，实际上每一种java基本数据类型（除了Boolean）都对应了一种缓冲区，例如：ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer。下面看一下Buffer对象基本操作的API：

package bhz.nio.test;

import java.nio.IntBuffer;

public class TestBuffer {

    public static void main(String[] args) {
		
        //创建指定长度的缓冲区
        IntBuffer buf = IntBuffer.allocate(10);
        buf.put(13);// position位置：0 - > 1
        buf.put(21);// position位置：1 - > 2
        buf.put(35);// position位置：2 - > 3
        //把位置复位为0，也就是position位置：3 - > 0
        System.out.println("position位置为：" + buf.position());
        buf.flip();
        System.out.println("使用flip复位：" + buf);
        System.out.println("最大容量为: " + buf.capacity());    //容量一旦初始化后不允许改变（warp方法包裹数组除外）
        System.out.println("当前容量为: " + buf.limit());        //由于只装载了三个元素,所以可读取或者操作的元素为3 则limit=3


        System.out.println("获取下标为1的元素：" + buf.get(1));
        System.out.println("get(index)方法，position位置不改变：" + buf);
        buf.put(1, 4);
        System.out.println("put(index, change)方法，position位置不变：" + buf);

        for (int i = 0; i < buf.limit(); i++) {
            //调用get方法会使其缓冲区位置（position）向后递增一位,所以在遍历之前一定要使用flip()方法进行复位
            System.out.print(buf.get() + "\t");
        }
        System.out.println();
        System.out.println("buf对象遍历之后为: " + buf);

    }
}

输出的结果如下：

position位置为：3
使用flip复位：java.nio.HeapIntBuffer[pos=0 lim=3 cap=10]
最大容量为: 10
当前容量为: 3
获取下标为1的元素：21
get(index)方法，position位置不改变：java.nio.HeapIntBuffer[pos=0 lim=3 cap=10]
put(index, change)方法，position位置不变：java.nio.HeapIntBuffer[pos=0 lim=3 cap=10]
13	4	35	
buf对象遍历之后为: java.nio.HeapIntBuffer[pos=3 lim=3 cap=10]

wrap()方法：

import java.nio.IntBuffer;

public class TestBuffer {

    public static void main(String[] args) {

        //  wrap方法会包裹一个数组: 一般这种用法不会先初始化缓存对象的长度，因为没有意义，最后还会被wrap所包裹的数组覆盖掉。
        //  并且wrap方法修改缓冲区对象的时候，数组本身也会跟着发生变化。
        int[] arr = new int[]{1, 2, 5};
        IntBuffer buf1 = IntBuffer.wrap(arr);
        System.out.println(buf1);

        IntBuffer buf2 = IntBuffer.wrap(arr, 0, 2);
        //这样使用表示容量为数组arr的长度，但是可操作的元素只有实际进入缓存区的元素长度
        System.out.println(buf2);
    }
}

输出结果如下：

java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
java.nio.HeapIntBuffer[pos=0 lim=2 cap=3]

Buffer的复制操作：

import java.nio.IntBuffer;

public class TestBuffer {

    public static void main(String[] args) {
        IntBuffer buf1 = IntBuffer.allocate(10);
        int[] arr = new int[]{1, 2, 5};
        buf1.put(arr);
        System.out.println(buf1);
        //一种复制方法
        IntBuffer buf2 = buf1.duplicate();
        System.out.println(buf2);

        //设置buf1的位置属性
        //buf1.position(0);
        buf1.flip();
        System.out.println(buf1);

        System.out.println("可读数据为：" + buf1.remaining());

        int[] arr2 = new int[buf1.remaining()];
        //将缓冲区数据放入arr2数组中去
        buf1.get(arr2);
        for (int i : arr2) {
            System.out.print(Integer.toString(i) + ",");
        }
    }
}

输出的执行结果如下：

java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
java.nio.HeapIntBuffer[pos=0 lim=3 cap=10]
可读数据为：3
1,2,5,

二.NIO

NIO的通信步骤如下：

  1. 创建ServerSocketChannel，为它配置非阻塞模式。
  2. 绑定监听，配置TCP参数，录入backlog大小等。
  3. 创建一个独立的IO线程，用于轮询多路复用器Selector
  4. 创建Selector，将之前创建的ServerSocketChannel注册到Selector上，并设置监听标志位SelectionKey.ACCEPT
  5. 启动IO线程，在循环体中执行Selector.select()方法，轮询就绪的通道。
  6. 当轮询到了处于就绪的通道时，需要进行判断操作位，如果是ACCEPT状态，说明是新的客户端接入，则调用accept方法接受新的客户端。
  7. 设置新接入客户端的一些参数如非阻塞，并将其通道继续注册到Selector之中，设置监听标志位等。
  8. 如果轮询的通道操作位是READ，则进行读取，构造BUFFER对象等。

一个简单的NIO服务端程序，就是如此的往复执行。Java NIO实现的实例代码如下：

服务端实现：Server.class

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Server implements Runnable {
    //1 多路复用器（管理所有的通道）
    private Selector seletor;
    //2 建立缓冲区
    private ByteBuffer readBuf = ByteBuffer.allocate(1024);
    //3 
    private ByteBuffer writeBuf = ByteBuffer.allocate(1024);

    public Server(int port) {
        try {
            //1 打开路复用器
            this.seletor = Selector.open();
            //2 打开服务器通道
            ServerSocketChannel ssc = ServerSocketChannel.open();
            //3 设置服务器通道为非阻塞模式
            ssc.configureBlocking(false);
            //4 绑定地址
            ssc.bind(new InetSocketAddress(port));
            //5 把服务器通道注册到多路复用器上，并且监听阻塞事件
            ssc.register(this.seletor, SelectionKey.OP_ACCEPT);

            System.out.println("Server start, port :" + port);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                //1 必须要让多路复用器开始监听
                this.seletor.select();
                //2 返回多路复用器已经选择的结果集
                Iterator<SelectionKey> keys = this.seletor.selectedKeys().iterator();
                //3 进行遍历
                while (keys.hasNext()) {
                    //4 获取一个选择的元素
                    SelectionKey key = keys.next();
                    //5 直接从容器中移除就可以了
                    keys.remove();
                    //6 如果是有效的
                    if (key.isValid()) {
                        //7 如果为阻塞状态
                        if (key.isAcceptable()) {
                            this.accept(key);
                        }
                        //8 如果为可读状态
                        if (key.isReadable()) {
                            this.read(key);
                        }
                        //9 写数据
                        if (key.isWritable()) {
                            //this.write(key); //ssc
                        }
                    }

                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void write(SelectionKey key) {
        //ServerSocketChannel ssc =  (ServerSocketChannel) key.channel();
        //ssc.register(this.seletor, SelectionKey.OP_WRITE);
    }

    private void read(SelectionKey key) {
        try {
            //1 清空缓冲区旧的数据
            this.readBuf.clear();
            //2 获取之前注册的socket通道对象
            SocketChannel sc = (SocketChannel) key.channel();
            //3 读取数据
            int count = sc.read(this.readBuf);
            //4 如果没有数据
            if (count == -1) {
                key.channel().close();
                key.cancel();
                return;
            }
            //5 有数据则进行读取 读取之前需要进行复位方法(把position 和limit进行复位)
            this.readBuf.flip();
            //6 根据缓冲区的数据长度创建相应大小的byte数组，接收缓冲区的数据
            byte[] bytes = new byte[this.readBuf.remaining()];
            //7 接收缓冲区数据
            this.readBuf.get(bytes);
            //8 打印结果
            String body = new String(bytes).trim();
            System.out.println("Server : " + body);

            // 9..可以写回给客户端数据 

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private void accept(SelectionKey key) {
        try {
            //1 获取服务通道
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            //2 执行阻塞方法
            SocketChannel sc = ssc.accept();
            //3 设置阻塞模式
            sc.configureBlocking(false);
            //4 注册到多路复用器上，并设置读取标识
            sc.register(this.seletor, SelectionKey.OP_READ);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

客户端实现代码：Client.class

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class Client {

	//需要一个Selector 
	public static void main(String[] args) {
		
		//创建连接的地址
		InetSocketAddress address = new InetSocketAddress("127.0.0.1", 8765);
		//声明连接通道
		SocketChannel sc = null;
		//建立缓冲区
		ByteBuffer buf = ByteBuffer.allocate(1024);
		try {
			//打开通道
			sc = SocketChannel.open();
			//进行连接
			sc.connect(address);
			while(true){
				//定义一个字节数组，然后使用系统录入功能：
				byte[] bytes = new byte[1024];
				System.in.read(bytes);
				
				//把数据放到缓冲区中
				buf.put(bytes);
				//对缓冲区进行复位
				buf.flip();
				//写出数据
				sc.write(buf);
				//清空缓冲区数据
				buf.clear();
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(sc != null){
				try {
					sc.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

Martiny66
关注
专栏目录
NIO总结文——一篇读懂NIO整个流程
qq_44587855的博客
07-26 759
服务器的工作 selector的准备工作 1.1 这里以windows平台为例会初始化一个WindowsSelectorImpl ServerSocketChannel的准备工作 2.1 向selector注册该ServerSocketChannel 3.1 会执行 Selector.register方法，首先在WindowsSelectorImpl的父类SelectorImpl创建一个SelectionsKeyImpl对象，参与到之后的整个注册过程 3.2 继续执行WindowsSelecto
NIO编程实现实例
02-21
4. **NIO编程流程**： - 打开通道：根据需求创建FileChannel、SocketChannel或ServerSocketChannel。 - 创建缓冲区：根据需要处理的数据类型创建对应的Buffer实例。 - 读写数据：使用通道与缓冲区交互，将数据从...
NIO与缓冲区
一枚野生程序员 —— Tim
02-08 688
Java NIO简介Java NIO (New IO/Non Blocking IO)，官方给的定义是New IO，但是我们也可以当作是Non Blocking IO，即非阻塞式IO，是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支 持面向缓冲区的、基于通道的...
NIO编程
dingchengyu的博客
04-10 630
NIO介绍 Java NIO 全称java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系 列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的. 1. NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器) 2. NIO是 面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了 处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络 3.
RPC框架设计(二)-NIO编程
路人贾的博客
05-07 299
2.NIO编程 2.1 NIO介绍 Java NIO全称java non-blocking IO，是指JDK提供的新API。从JDK1.4开始，Java提供了一系列改进的输入/输出的新特性，被统称为NIO（即 New IO），是同步非阻塞的。 1.NIO有三大核心部分：Channel(通道)、Buffer(缓冲区)、Selector(选择器) 2.NIO是面向缓冲区编程的。数据读取到一个缓冲区中，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞时的高伸缩性风格 3.Java N
Java NIO 网络编程初探
12-22
Java NIO 网络编程初探 1. Java NIO Java 1.4 版本添加了一个新的IO API，称为NIO（New IO）。NIO拥有所有IO的功能，但是操作方法却完全不一样。NIO支持面向缓冲区的、基于通道的IO操作。能够更加高效的进行IO操作。...
详细介绍 NIO与Netty编程-实战讲义详细pdf.7z
03-09
**NIO（非阻塞I/O）与Netty编程**是现代Java网络应用开发中的重要技术，它们在处理高并发、低延迟的网络通信场景中起着关键作用。本讲义详细介绍了这两种技术，旨在帮助开发者更好地理解和运用它们。 ### 一、BIO...
NIO编程技术指南_预览版
10-08
综上所述，NIO编程技术是Java中处理高性能并发I/O的重要工具，对于开发高可用、高并发的服务端应用具有重大意义。通过深入理解和熟练运用NIO，开发者能够构建出更高效、更灵活的系统。《NIO与Socket编程技术指南》_...
转:Java NIO 详解
weixin_30455661的博客
12-05 154
<!-- [if gte mso 10]> 上图就是这个项目的总体结构图，从图中可以看出该程序分为这几大块：连接侦听线程、连接对象队列、发送线程池、接收线程池、分发线程、事件处理对象、监控处理对象。下面我将描述下整个连接处理过程： 1、 连接侦听线程循环接收一个连接请求，如果有连接请求过来，则返回一个连接Socket对象，否则该线程就阻塞等待，直到有一个...
Nio编程
一条菜菜鱼
11-16 161
Bio和Nio的区别：bio为阻塞式io,nio为非阻塞式io。 文件NIO:文件必须先经过buffer才能进行读或者写操作。 buffer API：ByteBuffer，存储字节数据到缓冲区 ShortBuffer，存储字符串数据到缓冲区CharBuffer，存储字符数据到缓冲区 IntBuffer，存储整数数据到缓冲区LongBuffer，存储长整型数据到缓冲区 DoubleBuffer，存储小数到缓冲区 FloatBuffer，存储小数到缓冲区 ByteBuffer常用API pub..
Java NIO通道编程详解
4. 关键API和类：如ByteBuffer、CharBuffer、IntBuffer、DoubleBuffer、BufferedReader、BufferedWriter等，这些类和接口是进行NIO编程时不可或缺的工具。 Socket A指的是使用Java的Socket编程接口进行网络通信。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值