java之NIO简介

Posted 爱上口袋的天空

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java之NIO简介相关的知识,希望对你有一定的参考价值。

一、NIO基本简介

NIO (New lO)也有人称之为java non-blocking lO是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java lO API。NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同,NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行,线程在读写IO期间不能干其他事情,比如调用socket.read()时,如果服务器一直没有数据传输过来,线程就一直阻塞,而NIO中可以配置socket为非阻塞模式。

  • NIO相关类都被放在java.nio包及子包下,并且对原java.io包中的很多类进行改写。
  • NIO有三大核心部分:Channel(通道),Buffer(缓冲区), Selector(选择器)
  • Java NlO的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。
  • 通俗理解:NIO是可以做到用一个线程来处理多个操作的。假设有1000个请求过来,根据实际情况,可以分配20或者80个线程来处理。不像之前的阻塞IO那样,非得分配1000个。

二、NIO 与 BIO的比较

  • BIO以流的方式处理数据,而NIO以块的方式处理数据,块I/O的效率比流IO高很多
  • BIO是阻塞的,NIO则是非阻塞的
  • BlO基于字节流和字符流进行操作,而NIO基于Channel(通道)和Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道

NIO可以先将数据写入到缓冲区,然后再有缓冲区写入通道,因此可以做到同步非阻塞

BIO则是面向的流,读写数据都是单向的。因此是同步阻塞。

 三、NIO 三大核心原理示意图

NIO有三大核心部分: Channel(通道),Buffer(缓冲区),Selector(选择器)

Buffer(缓冲区)

        缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象,并提供了一组方法,用来方便的访问该块内存。相比较直接对数组的操作,Buffer APl更加容易操作和管理。

Channel(通道)

        Java NIO的通道类似流,但又有些不同:既可以从通道中读取数据,又可以写数据到通道。但流的(input或output)读写通常是单向的。通道可以非阻塞读取和写入通道,通道可以支持读取或写入缓冲区,也支持异步地读写。

Selector(选择器)

        Selector是一个ava NIO组件,可以能够检查一个或多个NIO通道,并确定哪些通道已经准备好进行读取或写入。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接,提高效率

  • 每个channel都会对应一个 Buffer
  • 一个线程对应Selector ,一个Selector对应多个channel(连接)程序
  • 切换到哪个channel是由事件决定的
  • Selector 会根据不同的事件,在各个通道上切换
  • Buffer 就是一个内存块,底层是一个数组
  • 数据的读取写入是通过 Buffer完成的,BlO中要么是输入流,或者是输出流,不能双向,但是NIO的Buffer是可以读也可以写。
  • Java NIO系统的核心在于:通道(Channel)和缓冲区(Buffer)。通道表示打开到lO设备(例如:文件、套接字)的连接。若需要使用NIO系统,需要获取用于连接IO设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区,对数据进行处理。简而言之,Channel负责传输,Buffer负责存取数据

四、NIO核心一:缓存区 (Buffer)

缓冲区(Buffer)一个用于特定基本数据类型的容器。由 java.nio 包定义的,所有缓冲区 都是 Buffer 抽象类的子类.。Java NIO 中的 Buffer 主要用于与 NIO 通道进行 交互数据是从通道读入缓冲区,从缓冲区写入通道中的

Buffer 类及其子类:

Buffer就像一个数组,可以保存多个相同类型的数据。根据 数据类型不同 ,有以下 Buffer 常用子类:  

  • ByteBuffer 
  • CharBuffer 
  • ShortBuffer 
  • IntBuffer 
  • LongBuffer 
  • FloatBuffer 
  • DoubleBuffer 

上述 Buffer 类他们都采用相似的方法进行管理数据,只是各自 管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象:

static XxxBuffer allocate(int capacity) : 创建一个容量为capacity 的 XxxBuffer 对象
 

缓冲区的基本属性 Buffer 中的重要概念:

容量 (capacity) :作为一个内存块,Buffer具有一定的固定大小, 也称为"容量",缓冲区容量不能为负,并且创建后不能更改。

限制 (limit):表示缓冲区中可以操作数据的大小 (limit 后数据不能进行读写)。缓冲区的限制不能 为负,并且不能大于其容量。 写入模式,限制等于 buffer的容量。读取模式下,limit等于写入的数据量。

位置 (position):下一个要读取或写入的数据的索引。 缓冲区的位置不能为 负,并且不能大于其限制

标记 (mark)与重置 (reset):标记是一个索引, 通过 Buffer 中的 mark() 方法 指定 Buffer 中一个 特定的 position,之后可以通过调用 reset() 方法恢 复到这 个 position.

标记、位置、限制、容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity

 Buffer常见方法:

  1. Buffer clear() :清空缓冲区并返回对缓冲区的引用
  2. Buffer flip() :为 将缓冲区的界限设置为当前位置, 并将当前位置重置为 0
  3. int capacity() :返回 Buffer 的 capacity 大小
  4. boolean hasRemaining(): 判断缓冲区中是否还有元素
  5. int limit() :返回 Buffer 的界限(limit) 的位置
  6. Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
  7. Buffer mark(): 对缓冲区设置标记
  8. int position() :返回缓冲区的当前位置 position
  9. Buffer position(int n) :将设置缓冲区的当前位置为 n, 并返回修改后的 Buffer 对象
  10. int remaining() :返回 position 和 limit 之间的元素个数
  11. Buffer reset() :将位置 position 转到以前设置的mark 所在的位置
  12. Buffer rewind() :将位置设为为 0, 取消设置的 mark

缓冲区的数据操作 Buffer 所有子类提供了两个用于数据操作的方法:

  1. get() :读取单个字节
  2. get(byte[] dst):批量读取多个字节到 dst 中
  3. get(int index):读取指定索引位置的字节(不会移动 position)放到入数据到Buffer中
  4. put(byte b):将给定单个字节写入缓冲区的当前位置
  5. put(byte[] src):将 src 中的字节写入缓冲区的当前位置
  6. put(int index, byte b):将指定字节写入缓冲区的索引 位置(不会移动 position)

使用Buffer读写数据一般遵循以下四个步骤:

  1. 写入数据到Buffer
  2. 调用flip()方法,转换为读取模式
  3. 从Buffer中读取数据
  4. 调用buffer.clear()方法或者buffer.compact()方 法清除缓冲区
package com.kgf.kgfjavalearning2021.io.nio;

import org.junit.Test;

import java.nio.ByteBuffer;

/***
 * Buffer测试类
 */
public class TestBuffer 

   @Test
   public void test1()
      //1. 分配一个指定大小的缓冲区
      ByteBuffer buf = ByteBuffer.allocate(1024);
      System.out.println("-----------------allocate()----------------");
      System.out.println(buf.position());// 0: 表示当前的位置为0
      System.out.println(buf.limit());// 1024: 表示界限为1024,前1024个位置是允许我们读写的
      System.out.println(buf.capacity());//1024:表示容量大小为1024

      //2. 利用 put() 存入数据到缓冲区中
      System.out.println("-----------------put()----------------");
      String str = "itheima";
      buf.put(str.getBytes());
      System.out.println(buf.position());// 7表示下一个可以写入的位置是7,因为我们写入的字节是7个,从0开始已经写了7个,位置为8的position为7
      System.out.println(buf.limit());// 1024:表示界限为1024,前1024个位置是允许我们读写的
      System.out.println(buf.capacity());//1024:表示容量大小为1024

      //3. 切换读取数据模式
      System.out.println("-----------------flip()----------------");
      buf.flip();
      System.out.println(buf.position());// 0: 读取的起始位置为0
      System.out.println(buf.limit());// 7: 表示界限为7,前7个位置有数据可以读取
      System.out.println(buf.capacity());// 1024:表示容量大小为1024

      //4. 利用 get() 读取缓冲区中的数据
      System.out.println("-----------------get()----------------");
      byte[] dst = new byte[buf.limit()];//创建一个界限为limit大小的字节数组
      buf.get(dst);//批量将limit大小的字节写入到dst字节数组中
      System.out.println(new String(dst, 0, dst.length));//结果为itheima

      System.out.println(buf.position());//7: 读取的位置变为7,因为前面的7个字节数据已经全部读取出去,下一个可读取的位置为7,从0开始的
      System.out.println(buf.limit());//7: 可读取的界限大小为7
      System.out.println(buf.capacity());// 1024: 表示容量大小为1024

      //5. rewind() : 可重复读
      System.out.println("-----------------rewind()----------------");
      buf.rewind();// 将位置设为为 0,从头开始读取
      System.out.println(buf.position());// 0
      System.out.println(buf.limit());// 7
      System.out.println(buf.capacity());// 1024

      //6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在,但是处于“被遗忘”状态
      System.out.println("-----------------clear()----------------");
      buf.clear();
      System.out.println(buf.position());// 0
      System.out.println(buf.limit());// 1024
      System.out.println(buf.capacity());// 1024
      System.out.println((char)buf.get());//i

   

   @Test
   public void test2()
      String str = "itheima";

      ByteBuffer buf = ByteBuffer.allocate(1024);

      buf.put(str.getBytes());// 将str写入到buf缓冲区中

      buf.flip();//转换为读模式

      byte[] dst = new byte[buf.limit()];//定义一个字节数组
      buf.get(dst, 0, 2);//将前2个字节批量写入到dst字节数组中
      System.out.println(new String(dst, 0, 2));//打印结果为it
      System.out.println(buf.position());//当前下一个读取的位置为2

      //mark() : 标记
      buf.mark();

      buf.get(dst, 2, 2);//从第3个位置开始将2个字节批量写入到dst字节数组中
      System.out.println(new String(dst, 2, 2));//打印结果为he
      System.out.println(buf.position());// 当前下一个读取的位置为4

      //reset() : 恢复到 mark 的位置
      buf.reset();
      System.out.println(buf.position());// 2

      //判断缓冲区中是否还有剩余数据
      if(buf.hasRemaining())
         //获取缓冲区中可以操作的数量
         System.out.println(buf.remaining());// 5: 返回 position 和 limit 之间的元素个数
      
   

   @Test
   public void test3()
      //分配直接缓冲区
      ByteBuffer buf = ByteBuffer.allocateDirect(1024);
      System.out.println(buf.isDirect());
   


直接与非直接缓冲区:

byte byffer可以是两种类型,一种是基于直接内存(也就是非堆内存);另一种是非直接内存(也就是堆内存)。对于直接内存来说,JVM将会在IO操作上具有更高的性能,因为它
直接作用于本地系统的IO操作
。而非直接内存,也就是堆内存中的数据,如果要作IO操作,会先从本进程内存复制到直接内存,再利用本地IO处理。

从数据流的角度,非直接内存是下面这样的作用链:

本地IO-->直接内存-->非直接内存-->直接内存-->本地IO

而直接内存是:

本地IO-->直接内存-->本地IO

很明显,在做IO处理时,比如网络发送大量数据时,直接内存会具有更高的效率。直接内存使用allocateDirect创建,但是它比申请普通的堆内存需要耗费更高的性能。不过,这部分的数据是在JVM之外的,因此它不会占用应用的内存。所以呢,当你有很大的数据要缓存,并且它的生命周期又很长,那么就比较适合使用直接内存。只是一般来说,如果不是能带来很明显的性能提升,还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect()  方法来确定。

使用场景

  1.  有很大的数据需要存储,它的生命周期又很长
  2.  适合频繁的IO操作,比如网络并发场景

五、NIO核心二:通道(Channel)

 1、通道Channe概述

        通道(Channel):由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据,Channel 只能与 Buffer 进行交互。

2、NIO 的通道类似于流,但有些区别如下:

  • 通道可以同时进行读写,而流只能读或者只能写

  • 通道可以实现异步读写数据

  • 通道可以从缓冲读数据,也可以写数据到缓冲:

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

4、Channel 在 NIO 中是一个接口

public interface Channel extends Closeable

5、常用的Channel实现类

  • FileChannel:用于读取、写入、映射和操作文件的通道。
  • DatagramChannel:通过 UDP 读写网络中的数据通道。
  • SocketChannel:通过 TCP 读写网络中的数据。
  • ServerSocketChannel:可以监听新进来的 TCP 连接,对每一个新进来的连接都会创建一个 SocketChannel。 【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】

6、FileChannel 类

获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下

  • FileInputStream
  • FileOutputStream
  • RandomAccessFile
  • DatagramSocket
  • Socket
  • ServerSocket
  • 获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道

7、FileChannel常用方法

  • int read(ByteBuffer dst) :从Channel 到 中读取数据到  ByteBuffer
  • long  read(ByteBuffer[] dsts) : 将Channel中的数据“分散”到  ByteBuffer[]
  • int  write(ByteBuffer src) :将  ByteBuffer中的数据写入到  Channel
  • long write(ByteBuffer[] srcs) :将  ByteBuffer[] 到 中的数据“聚集”到  Channel
  • long position() :返回此通道的文件位置
  • FileChannel position(long p) :设置此通道的文件位置
  • long size() :返回此通道的文件的当前大小
  • FileChannel truncate(long s) :将此通道的文件截取为给定大小
  • void force(boolean metaData) :强制将所有对此通道的文件更新写入到存储设备中

8、案例1-本地文件写数据

package com.kgf.kgfjavalearning2021.io.nio;

import org.junit.Test;

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

/***
 * 需求:使用前面学习后的 ByteBuffer(缓冲)和 FileChannel(通道), 将数据写入到 data.txt 中.
 */
public class ChannelTest 

    @Test
    public void write()
        try 
            // 1、字节输出流通向目标文件
            FileOutputStream fos = new FileOutputStream("E:\\\\test\\\\data01.txt");
            // 2、得到字节输出流对应的通道Channel
            FileChannel channel = fos.getChannel();
            // 3、分配缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            for (int i = 0; i < 10; i++) 
                buffer.clear();//清空缓冲区
                buffer.put(("hello,使用Buffer和channel实现写数据到文件中"+i+"\\r\\n").getBytes());
                // 4、把缓冲区切换成写出模式
                buffer.flip();
                channel.write(buffer);//将缓冲区的数据写入到文件通道
            
            channel.close();
            System.out.println("写数据到文件中!");
         catch (Exception e) 
            e.printStackTrace();
        
    


9、案例2-本地文件读数据

 /***
     * 设置两个缓冲区,一大一小,大的缓冲区为每次读取的量,小的缓冲区存放每行的数据(确保大小可存放文本中最长的那行)。读取的时候判断是不是换行符13,是的话则返回一行数据,不是的话继续读取,直到读完文件。
     * @throws Exception
     */
    @Test
    public void read() throws Exception 
        // 1、定义一个文件字节输入流与源文件接通
        FileInputStream is = new FileInputStream("E:\\\\test\\\\data01.txt");
        // 2、需要得到文件字节输入流的文件通道
        FileChannel channel = is.getChannel();
        // 3、定义一个缓冲区
        int bufferSize = 1024 * 1024;  // 每一块的大小
        ByteBuffer buffer = ByteBuffer.allocate(bufferSize);

        ByteBuffer bb = ByteBuffer.allocate(1024);

        // 4、读取数据到缓冲区
        int bytesRead = channel.read(buffer);
        while (bytesRead != -1) 
            buffer.flip();// 切换模式,写->读
            while (buffer.hasRemaining()) //返回 position 和 limit 之间的元素个数
                    byte b = buffer.get();
                    if (b == 10 || b == 13)  // 换行或回车
                        bb.flip();
                        // 这里就是一个行
                        final String line = Charset.forName("utf-8").decode(bb).toString();
                        System.out.println(line);// 解码已经读到的一行所对应的字节
                        bb.clear();
                     else 
                        if (bb.hasRemaining())
                            bb.put(b);
                        else  // 空间不够扩容
                            bb = reAllocate(bb);
                            bb.put(b);
                        
                    
            
            buffer.clear();// 清空,position位置为0,limit=capacity
            //  继续往buffer中写
            bytesRead = channel.read(buffer);
        
        channel.close();
    

10、案例3-使用Buffer完成文件复制

  /**
     * 使用 FileChannel(通道) ,完成文件的拷贝。
     * @throws Exception
     */
    @Test
    public void copy() throws Exception 
        // 源文件
        File srcFile = new File("E:\\\\test\\\\Aurora-4k.jpg");
        File destFile = new File("E:\\\\test\\\\Aurora-4k-new.jpg");
        // 得到一个字节字节输入流
        FileInputStream fis = new FileInputStream(srcFile);
        // 得到一个字节输出流
        FileOutputStream fos = new FileOutputStream(destFile);
        // 得到的是文件通道
        FileChannel isChannel = fis.getChannel();
        FileChannel osChannel = fos.getChannel();
        // 分配缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while(isChannel.read(buffer)>0)
            // 已经读取了数据 ,把缓冲区的模式切换成可读模式
            buffer.flip();
            // 把数据写出到
            osChannel.write(buffer);//将buffer缓冲区中的数据写入到osChannel中
            // 必须先清空缓冲然后再写入数据到缓冲区
            buffer.clear();
        
        isChannel.close();
        osChannel.close();
        System.out.println("复制完成!");
    

11、案例4-transferFrom()

从目标通道中去复制原通道数据

 @Test
    public void test02() throws Exception 
        // 1、字节输入管道
        FileInputStream is = new FileInputStream("E:\\\\test\\\\Aurora-4k.jpg");
        FileChannel isChannel = is.getChannel();
        // 2、字节输出流管道
        FileOutputStream fos = new FileOutputStream("E:\\\\test\\\\Aurora-4knew3.jpg");
        FileChannel osChannel = fos.getChannel();
        // 3、复制
        osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
        isChannel.close();
        osChannel.close();
    

12、案例5-transferTo()

把原通道数据复制到目标通道

 @Test
    public void test03() throws Exception 
        // 1、字节输入管道
        FileInputStream is = new FileInputStream("E:\\\\test\\\\Aurora-4k.jpg");
        FileChannel isChannel = is.getChannel();
        // 2、字节输出流管道
        FileOutputStream fos = new FileOutputStream("E:\\\\test\\\\Aurora-4knew4.jpg");
        FileChannel osChannel = fos.getChannel();
        // 3、复制
        isChannel.transferTo(isChannel.position() , isChannel.size() , osChannel);
        isChannel.close();
        osChannel.close();
    

13、案例6-分散 (Scatter) 和聚集 (Gather)

  • 分散读取(Scatter ):是指把Channel通道的数据读入到 多个缓冲区中去
  • 聚集写入(Gathering )是指将多个 Buffer 中的数 据“聚集”到 Channel。
//分散和聚集
@Test
public void test() throws IOException
		RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
	//1. 获取通道
	FileChannel channel1 = raf1.getChannel();
	
	//2. 分配指定大小的缓冲区
	ByteBuffer buf1 = ByteBuffer.allocate(100);
	ByteBuffer buf2 = ByteBuffer.allocate(1024);
	
	//3. 分散读取
	ByteBuffer[] bufs = buf1, buf2;
	channel1.read(bufs);
	
	for (ByteBuffer byteBuffer : bufs) 
		byteBuffer.flip();
	
	
	System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
	System.out.println("-----------------");
	System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
	
	//4. 聚集写入
	RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
	FileChannel channel2 = raf2.getChannel();
	
	channel2.write(bufs);


六、NIO核心三:选择器(Selector)

1、选择器(Selector)概述

        选择器(Selector)是SelectableChannle对象多路复用器,Selector可以同时监控多个SelectableChannel的IO状况,也就是说,利用Selector可使一个单独的线程管理多个Channel。Selector是非阻塞IO的核心。

  • Java 的 NIO,用非阻塞的 IO 方式。可以用一个线程,处理多个的客户端连接,就会使用到 Selector(选择器)
  • Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个(Selector),如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管
  • 理多个通道,也就是管理多个连接和请求。
  • 只有在连接/通道真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程
  • 避免了多线程之间的上下文切换导致的开销

2、选择器的应用

创建 Selector :通过调用 Selector.open() 方法创建一个 Selector。

Selector selector = Selector.open();

向选择器注册通道:SelectableChannel.register(Selector sel, int ops)

//1. 获取通道
ServerSocketChannel ssChannel = ServerSocketChannel.open();
//2. 切换非阻塞模式
ssChannel.configureBlocking(false);
//3. 绑定连接
ssChannel.bind(new InetSocketAddress(9898));
//4. 获取选择器
Selector selector = Selector.open();
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

当调用 register(Selector sel, int ops) 将通道注册选择器时,选择器对通道的监听事件,需要通过第二个参数 ops 指定。可以监听的事件类型(用 可使用 SelectionKey 的四个常量 表示):

  • 读 : SelectionKey.OP_READ (1)
  • 写 : SelectionKey.OP_WRITE (4)
  • 连接 : SelectionKey.OP_CONNECT (8)
  • 接收 : SelectionKey.OP_ACCEPT (16)

若注册时不止监听一个事件,则可以使用“位或”操作符连接。
int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE


3、NIO非阻塞式网络通信原理分析

3.1、Selector 示意图和特点说明

        Selector可以实现: 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作,这从根本上解决了传统同步阻塞 I/O 一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

3.2、服务端流程

 1)、获取通道。当客户端连接服务端时,服务端会通过 ServerSocketChannel 得到 SocketChannel:

 ServerSocketChannel ssChannel = ServerSocketChannel.open();

2)、切换非阻塞模式

 ssChannel.configureBlocking(false);

3)、绑定连接

 ssChannel.bind(new InetSocketAddress(8888));

4)、获取选择器

Selector selector = Selector.open();

5)、将通道注册到选择器上, 并且指定“监听接收事件”

ssChannel.register(selector, SelectionKey.OP_ACCEPT);

6)、轮询式的获取选择器上已经“准备就绪”的事件

while (selector.select() > 0)
    System.out.println("开启事件处理");
    //7.获取选择器中所有注册的通道中已准备好的事件
    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
    //8.开始遍历事件
    while (it.hasNext())
        SelectionKey selectionKey = it.next();
        System.out.println("--->"+selectionKey);
        //9.判断这个事件具体是啥
        if (selectionKey.isAcceptable())
            //10.获取当前接入事件的客户端通道
            SocketChannel socketChannel = serverSocketChannel.accept();
            //11.切换成非阻塞模式
            socketChannel.configureBlocking(false);
            //12.将本客户端注册到选择器
            socketChannel.register(selector,SelectionKey.OP_READ);
        else if (selectionKey.isReadable())
            //13.获取当前选择器上的读
            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
            //14.读取
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int len;
            while ((len = socketChannel.read(buffer)) > 0)
                buffer.flip();
                System.out.println(new String(buffer.array(),0,len));
                //清除之前的数据(覆盖写入)
                buffer.clear();
            
        
        //15.处理完毕后,移除当前事件
        it.remove();
    


3.3、客户端流程

1)、获取通道

SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888));

2)、切换非阻塞模式

sChannel.configureBlocking(false);

3)、分配指定大小的缓冲区

ByteBuffer buffer = ByteBuffer.allocate(1024);

4)、发送数据给绑定的服务端

Scanner scan = new Scanner(System.in);
while(scan.hasNext())
	String str = scan.nextLine();
	buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
			+ "\\n" + str).getBytes());
	buf.flip();
	sChannel.write(buf);
	buf.clear();

//关闭通道
sChannel.close();

4、NIO非阻塞式网络通信入门案例

需求:服务端接收客户端的连接请求,并接收多个客户端发送过来的事件。

Server端代码实现:

package nio.ss;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class Server 
    public static void main(String[] args) 
        try 
            //1.获取管道
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            //2.设置非阻塞模式
            serverSocketChannel.configureBlocking(false);
            //3.绑定端口
            serverSocketChannel.bind(new InetSocketAddress(8888));
            //4.获取选择器
            Selector selector = Selector.open();
            //5.将通道注册到选择器上,并且开始指定监听的接收事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            //6.轮询已经就绪的事件
            while (selector.select() > 0)
                System.out.println("开启事件处理");
                //7.获取选择器中所有注册的通道中已准备好的事件
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                //8.开始遍历事件
                while (it.hasNext())
                    SelectionKey selectionKey = it.next();
                    System.out.println("--->"+selectionKey);
                    //9.判断这个事件具体是啥
                    if (selectionKey.isAcceptable())
                        //10.获取当前接入事件的客户端通道
                        SocketChannel socketChannel = serverSocketChannel.accept();
                        //11.切换成非阻塞模式
                        socketChannel.configureBlocking(false);
                        //12.将本客户端注册到选择器
                        socketChannel.register(selector,SelectionKey.OP_READ);
                    else if (selectionKey.isReadable())
                        //13.获取当前选择器上的读
                        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                        //14.读取
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int len;
                        while ((len = socketChannel.read(buffer)) > 0)
                            buffer.flip();
                            System.out.println(new String(buffer.array(),0,len));
                            //清除之前的数据(覆盖写入)
                            buffer.clear();
                        
                    
                    //15.处理完毕后,移除当前事件
                    it.remove();
                
            
         catch (IOException e) 
            e.printStackTrace();
        
    

Client端代码实现:

package nio.ss;

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

public class Client 
    public static void main(String[] args) 
        try 
            SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8888));
            socketChannel.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            Scanner scanner = new Scanner(System.in);
            while (true)
                System.out.print("请输入:");
                String msg = scanner.nextLine();
                buffer.put(msg.getBytes());
                buffer.flip();
                socketChannel.write(buffer);
                buffer.clear();
            
         catch (IOException e) 
            e.printStackTrace();
        
    


5、NIO 网络编程应用实例-群聊系统

需求:进一步理解 NIO 非阻塞网络编程机制,实现多人群聊

  • 编写一个 NIO 群聊系统,实现客户端与客户端的通信需求(非阻塞)
  • 服务器端:可以监测用户上线,离线,并实现消息转发功能
  • 客户端:通过 channel 可以无阻塞发送消息给其它所有客户端用户,同时可以接受其它客户端用户通过服务端转发来的消息

服务端代码:

package nio.chat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

/**
 *
 */
public class Server 
    //定义属性
    private Selector selector;
    private ServerSocketChannel ssChannel;
    private static final int PORT = 9999;
    //构造器
    //初始化工作
    public Server() 
        try 
            // 1、获取通道
            ssChannel = ServerSocketChannel.open();
            // 2、切换为非阻塞模式
            ssChannel.configureBlocking(false);
            // 3、绑定连接的端口
            ssChannel.bind(new InetSocketAddress(PORT));
            // 4、获取选择器Selector
            selector = Selector.open();
            // 5、将通道都注册到选择器上去,并且开始指定监听接收事件
            ssChannel.register(selector , SelectionKey.OP_ACCEPT);
        catch (IOException e) 
            e.printStackTrace();
        
    
    //监听
    public void listen() 
        System.out.println("监听线程:" + Thread.currentThread().getName());
        try 
            while (selector.select() > 0)
                // 7、获取选择器中的所有注册的通道中已经就绪好的事件
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                // 8、开始遍历这些准备好的事件
                while (it.hasNext())
                    // 提取当前这个事件
                    SelectionKey sk = it.next();
                    // 9、判断这个事件具体是什么
                    if(sk.isAcceptable())
                        // 10、直接获取当前接入的客户端通道
                        SocketChannel schannel = ssChannel.accept();
                        // 11 、切换成非阻塞模式
                        schannel.configureBlocking(false);
                        // 12、将本客户端通道注册到选择器
                        System.out.println(schannel.getRemoteAddress() + " 上线 ");
                        schannel.register(selector , SelectionKey.OP_READ);
                        //提示
                    else if(sk.isReadable())
                        //处理读 (专门写方法..)
                        readData(sk);
                    

                    it.remove(); // 处理完毕之后需要移除当前事件
                
            
        catch (Exception e) 
            e.printStackTrace();
        finally 
            //发生异常处理....

        
    

    //读取客户端消息
    private void readData(SelectionKey key) 
        //获取关联的channel
        SocketChannel channel = null;
        try 
            //得到channel
            channel = (SocketChannel) key.channel();
            //创建buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = channel.read(buffer);
            //根据count的值做处理
            if(count > 0) 
                //把缓存区的数据转成字符串
                String msg = new String(buffer.array());
                //输出该消息
                System.out.println("来自客户端---> " + msg);
                //向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
                sendInfoToOtherClients(msg, channel);
            
        catch (IOException e) 
            try 
                System.out.println(channel.getRemoteAddress() + " 离线了..");
                e.printStackTrace();
                //取消注册
                key.cancel();
                //关闭通道
                channel.close();
            catch (IOException e2) 
                e2.printStackTrace();;
            
        
    

    //转发消息给其它客户(通道)
    private void sendInfoToOtherClients(String msg, SocketChannel self ) throws  IOException
        System.out.println("服务器转发消息中...");
        System.out.println("服务器转发数据给客户端线程: " + Thread.currentThread().getName());
        //遍历 所有注册到selector 上的 SocketChannel,并排除 self
        for(SelectionKey key: selector.keys()) 
            //通过 key  取出对应的 SocketChannel
            Channel targetChannel = key.channel();
            //排除自己
            if(targetChannel instanceof  SocketChannel && targetChannel != self) 
                //转型
                SocketChannel dest = (SocketChannel)targetChannel;
                //将msg 存储到buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                //将buffer 的数据写入 通道
                dest.write(buffer);
            
        
    

    public static void main(String[] args) 
        //创建服务器对象
        Server groupChatServer = new Server();
        groupChatServer.listen();
    

客户端代码:

package nio.chat;

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;
import java.util.Scanner;

public class Client 
    //定义相关的属性
    private final String HOST = "127.0.0.1"; // 服务器的ip
    private final int PORT = 9999; //服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    //构造器, 完成初始化工作
    public Client() throws IOException 
        selector = Selector.open();
        //连接服务器
        socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
        //设置非阻塞
        socketChannel.configureBlocking(false);
        //将channel 注册到selector
        socketChannel.register(selector, SelectionKey.OP_READ);
        //得到username
        username = socketChannel.getLocalAddress().toString().substring(1);
        System.out.println(username + " is ok...");
    

    //向服务器发送消息
    public void sendInfo(String info) 
        info = username + " 说:" + info;
        try 
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        catch (IOException e) 
            e.printStackTrace();
        
    

    //读取从服务器端回复的消息
    public void readInfo() 
        try 
            int readChannels = selector.select();
            if(readChannels > 0) //有可以用的通道

                Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                while (iterator.hasNext()) 

                    SelectionKey key = iterator.next();
                    if(key.isReadable()) 
                        //得到相关的通道
                        SocketChannel sc = (SocketChannel) key.channel();
                        //得到一个Buffer
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        //读取
                        sc.read(buffer);
                        //把读到的缓冲区的数据转成字符串
                        String msg = new String(buffer.array());
                        System.out.println(msg.trim());
                    
                
                iterator.remove(); //删除当前的selectionKey, 防止重复操作
             else 
                //System.out.println("没有可以用的通道...");
            
        catch (Exception e) 
            e.printStackTrace();
        
    

    public static void main(String[] args) throws Exception 
        //启动我们客户端
        Client chatClient = new Client();
        //启动一个线程, 每个3秒,读取从服务器发送数据
        new Thread() 
            public void run() 
                while (true) 
                    chatClient.readInfo();
                    try 
                        Thread.currentThread().sleep(3000);
                    catch (InterruptedException e) 
                        e.printStackTrace();
                    
                
            
        .start();

        //发送数据给服务器端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) 
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        
    


七、AIO 深入剖析

Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

AIO:异步非阻塞,基于NIO的,可以称之为NIO2.0

    BIO                   NIO                              AIO        
Socket                SocketChannel                    AsynchronousSocketChannel
ServerSocket          ServerSocketChannel	       AsynchronousServerSocketChannel

与NIO不同,当进行读写操作时,只须直接调用API的read或write方法即可, 这两种方法均为异步的,对于读操作而言,当有流可读取时,操作系统会将可读的流传入read方法的缓冲区,对于写操作而言,当操作系统将write方法传递的流写入完毕时,操作系统主动通知应用程序

即可以理解为,read/write方法都是异步的,完成后会主动调用回调函数。在JDK1.7中,这部分内容被称作NIO.2,主要在Java.nio.channels包下增加了下面四个异步通道:

  • AsynchronousSocketChannel
  • ​ AsynchronousServerSocketChannel
  • ​ AsynchronousFileChannel
  • ​ AsynchronousDatagramChannel

八、总结

BIO、NIO、AIO:

  • Java BIO : 同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。
  • Java NIO : 同步非阻塞,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
  • Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

BIO、NIO、AIO适用场景分析:

  • BIO方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4以前的唯一选择,但程序直观简单易理解。
  • NIO方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局限于应用中,编程比较复杂,JDK1.4开始支持。
  • AIO方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用OS参与并发操作,编程比较复杂,JDK7开始支持。Netty!

以上是关于java之NIO简介的主要内容,如果未能解决你的问题,请参考以下文章

Java NIO之缓冲区

Java NIO之缓冲区

NIO之Buffer的clear()rewind()flip()方法的区别

## 20155336 2016-2017-2《JAVA程序设计》第八周学习总结

java NIO之Pipe

全新Java入门到架构师课程之Java15编程基础-数组:数组声明初始化数组元素的界限和遍历