NIO专题（二）

linxc008

于 2024-08-02 15:55:12 发布

阅读量628

点赞数 30

文章标签： nio java

本文链接：https://blog.csdn.net/linxc008/article/details/140872508

版权

接上一篇内容…

四、JAVA NIO深入剖析

在讲解利用NIO实现通信架构之前，我们需要先来了解一下NIO的基本特点和使用

1. Java NIO基本介绍

java NlO (New lO）也有人称之为java non-blocking IO，是Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。 NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO，传统的IO 的read和write只能阻塞执行，线程在读写期间不能干其他事情，比如调用socket. read(）时，如果服务器一直没有数据传输过来，线程就一直阻塞，而NIO中可以配置socket为非阻塞模式
NIO相关类都被放在java.nio包及子包下，并且对原 Java.io 包中的很多类进行改写。
NIO有三大核心部分：Channel（通道），Buffer(缓冲区），Selector（选择器）
Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据；如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。
通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有1000个请求过来，根据实际情况，可以分配20或者80个线程来处理。不像之前的阻塞IO那样，非得分配1000个。

2. NIO和BIO的比较

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

3. NIO三大核心原理示意图

NIO有三大核心部分：Channel(通道)，Buffer(缓存区)，Selector(选择器)

Buffer缓存区

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

Channel通道

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

Selector选择器

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

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

4. NIO核心一：缓存区（Buffer)

缓存区（Buffer）

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

Buffer类及其子类

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

ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer

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

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

缓存区的基本属性

Buffer中的重要概念：

容量（capacity)： 作为一个内存块，Buffer具有一定的固定大小，也称为”容量”，缓冲区容量不能为负，并且创建后不能更改。
限制（limit)： 表示缓冲区中可以操作数据的大小（limit后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量。
位置（position)： 下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
标记（mark）与重置（reset)： 标记是一个索引，通过Buffer中的mark(）方法指定Buffer中一个特定的 position，之后可以通过调用reset(）方法恢复到这个position。标记、位置、限制、容量。遵守以下式： 0<=mark<=position<=limit<=capacity

图示：

Buffer常见方法

Buffer clear(）清空缓冲区并返回对缓冲区的引用
Buffer flip(）为将缓冲区的界限设置为当前位置，并将当前位置重置为0
int capacity(）返回Buffer的capacity大小
boolean hasRemaining(）判断缓冲区中是否还有元素
int limit(）返回Buffer的界限（limit）的位置
Buffer limit(int n）将设置缓冲区界限为n，并返回一个具有新limit的缓冲区对象
Buffer mark(）对缓冲区设置标记
int position(）返回缓冲区的当前位置position
Buffer position(int n）将设置缓冲区的当前位置为n，并返回修改后的Buffer对象
int remaining()返回position和limit之间的元素个数
Buffer reset(）将位置position转到以前设置的mark所在的位置
Buffer rewind();将位置设为为0．取消设置的mark

缓存区的数据操作

Buffer所有子类提供了两个用于数据操作的方法：get()和put()

获取Buffer中的数据

get()：读取单个字节
get (byte[] dst)：批量读取多个字节到dst中
get(int index)：读取指定索引位置的字节（不会移动position)

放入数据到Buffer中

put(byte b)：将给定单个字节写入缓冲区的当前位置
put (byte[] src)：将src中的字节写入缓存区的当前位置
put(int index,byte b)：将指定字节写入缓存区的索引位置（不会移动position）

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

写入数据到Buffer
调用flip()方法，转换为读取模式
从Buffer中读取数据
调用buffer.clear()方法或者buffer.compact()方法清除缓存区

案例演示

import org.junit.Test;
import java.nio.ByteBuffer;
//目标：对缓存区Buffer的常用API进行案例实现
public class BufferTest {
    @Test
    public void test01(){
        //1.设置一个缓冲区，设置容量为10
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //2.往缓冲区放入数据
        String name = "linxc";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());//5
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //3.flip() 将缓冲区的界限设置为当前位置，并将当前位置设置为0 可读模式
        buffer.flip();
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//5
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //4. get数据的读取
        char ch = (char) buffer.get();
        System.out.println(ch);//l
        System.out.println(buffer.position());//1
        System.out.println(buffer.limit());//5
        System.out.println(buffer.capacity());//10
        //再读一次
        char ch1 = (char) buffer.get();
        System.out.println(ch1);//i
        System.out.println(buffer.position());//2
        System.out.println(buffer.limit());//5
        System.out.println(buffer.capacity());//10
    }

    @Test
    public void test02() {
        //1.分配一个缓存区，容量设置为10
        ByteBuffer buffer = ByteBuffer.allocate(10);
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        String name = "linxc";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());//5
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println("-----------------------");
        //2.clear 清楚缓存区中的数据
        buffer.clear();
        System.out.println(buffer.position());//0
        System.out.println(buffer.limit());//10
        System.out.println(buffer.capacity());//10
        System.out.println((char) buffer.get());//l 表明数据并没有清除 只是恢复了position的位置
        System.out.println("-----------------------");
        //3.定义一个缓存区
        ByteBuffer buf = ByteBuffer.allocate(10);
        String n = "linxc";
        buf.put(n.getBytes());
        buf.flip();
        //读取数据
        byte[] b = new byte[2];
        buf.get(b);
        String rs = new String(b);
        System.out.println(rs);//li
        System.out.println(buf.position());//2
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//10
        System.out.println("-----------------------");
        buf.mark();//标记此刻这个位置：2
        byte[] b2 = new byte[3];
        buf.get(b2);
        System.out.println(new String(b2));//nxc
        System.out.println(buf.position());//5
        System.out.println(buf.limit());//5
        System.out.println(buf.capacity());//10
        System.out.println("-----------------------");
        buf.reset();//回到标记位置 2
        if (buf.hasRemaining()) {
            System.out.println(buf.remaining());//3
        }
    }
}

直接与非直接缓存区

什么是直接内存与非直接内存

根据官方文档的描述：

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

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

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

而直接内存是：

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

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

验证代码：

@Test
    public void test03() {
        //创建非直接内存的缓冲区
        ByteBuffer buf1 = ByteBuffer.allocate(1024);
        //buffer.isDirect()用于判断是否为直接内存
        System.out.println(buf1.isDirect());
        System.out.println("---------------------------");
        //创建直接内存的缓冲区
        ByteBuffer buf2 = ByteBuffer.allocateDirect(1024);
        System.out.println(buf2.isDirect());
    }

执行结果：

false
---------------------------
true

使用场景

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

5. NIO核心二：通道（Channel）

Channel概述

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

NIO的通道类似于流，但有些区别如下

通道可以同时进行读写，而流只能读或者只能写
通道可以实现异步读写数据
通道可以从缓冲读数据，也可以写数据到缓冲

BlO中的stream是单向的，例如FilelnputStream对象只能进行读取数据的操作，而NIO中的通道（Channel）是双向的，可以读操作，也可以写操作。
Channel在NIO中是一个接口

public interface Channel extends Closeable()

常用的Channel实现类

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

FileChannel类

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

FileInputStream
FileOutputStream
RandomAccessFile
DatagramSocket
Socket
ServerSocket

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

FileChannel的常用方法

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

案例1-本地文件写数据

import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ChannelTest {
    /**
     * 写入
     */
    @Test
    public void test01(){
        try {
            //1.获取输出流，用于获取channel
            FileOutputStream fos = new FileOutputStream("data1.txt");
            //2.得到字节输出流对应的通道
            FileChannel channel = fos.getChannel();
            //3.分配缓冲区
            ByteBuffer buf = ByteBuffer.allocate(1024);
            buf.put("hello!中国".getBytes());
            //4.切换模式
            buf.flip();
            channel.write(buf);
            channel.close();
            System.out.println("写入成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

执行结果：

案例2-本地文件读数据

/**
 * 读取
 */
@Test
public void test02(){
    try {
        //1.获取文件输入流，用于获取通道
        FileInputStream fis = new FileInputStream("data1.txt");
        //2.需要得到文件字节输入流的通道
        FileChannel channel = fis.getChannel();
        //3.定义一个缓冲区
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //4.读取数据到缓冲区
        channel.read(buf);
        //5.把缓冲区的内容输出
        buf.flip();
        String str = new String(buf.array(),0,buf.remaining());
        System.out.println(str);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

执行结果：

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

/**
 * 复制
 */
@Test
public void test03() throws Exception {
    //源文件和目标文件
    File srcFile = new File("D:\\Desktop\\2023年7月25日211452.mp4");
    File descFile = new File("D:\\Desktop\\复制.mp4");
    //字节输入流和字节输出流
    FileInputStream fis = new FileInputStream(srcFile);
    FileOutputStream fos = new FileOutputStream(descFile);
    //得到文件通道
    FileChannel fisChannel = fis.getChannel();
    FileChannel fosChannel = fos.getChannel();
    //分配缓冲区
    ByteBuffer buf = ByteBuffer.allocate(1024);
    while (true){
        //必须先清空缓存区再写入数据
        buf.clear();
        int flag = fisChannel.read(buf);
        if (flag == -1){
            break;
        }
        //已经读取了数据，切换模式写入
        buf.flip();
        fosChannel.write(buf);
    }
    fisChannel.close();
    fosChannel.close();
    System.out.println("复制完成！");
}

案例4-分散（Scatter)和聚集（Gatter)

分散读取（Scatter)：是指把Channel通道的数据读取到多个缓存区中去

聚集写入（Gathering)：是指将多个Buffer中的数据聚集到Channel。

/**
 * 文件复制：分散和聚集
 * @throws Exception
 */
@Test
public void test04() throws Exception {
    //1.字节输入管道
    FileInputStream fis = new FileInputStream("data1.txt");
    FileChannel fisChannel = fis.getChannel();
    //2.字节输出管道
    FileOutputStream fos = new FileOutputStream("data2.txt");
    FileChannel fosChannel = fos.getChannel();
    //3.定义多个缓冲区做数据分散
    ByteBuffer buf1 = ByteBuffer.allocate(4);
    ByteBuffer buf2 = ByteBuffer.allocate(1024);
    ByteBuffer[] buffers = {buf1,buf2};
    //4.从通道中读取数据分散到多个缓冲区
    fisChannel.read(buffers);
    //5.从每个缓冲区查询是否有数据读取到
    for (ByteBuffer buffer : buffers) {
        buffer.flip();//切换到读模式
        System.out.println(new String(buffer.array(),0,buffer.remaining()));
    }
    //6.聚集写入到通道
    fosChannel.write(buffers);
    fisChannel.close();
    fosChannel.close();
    System.out.println("文件复制成功~");
}

案例5-transferForm()

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

@Test
public void test05() throws Exception {
    //获取通道
    FileInputStream fis = new FileInputStream("D:\\Desktop\\2023年7月25日211452.mp4");
    FileChannel fisChannel = fis.getChannel();
    FileOutputStream fos = new FileOutputStream("D:\\Desktop\\transferfrom.mp4");
    FileChannel fosChannel = fos.getChannel();
    fosChannel.transferFrom(fisChannel,fisChannel.position(),fisChannel.size());
    System.out.println("使用transferfrom复制成功！");
}

案例6-transferTo()

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

@Test
public void test06() throws Exception{
    //1.字节输入管道
    FileInputStream is = new FileInputStream("data1.txt");
    FileChannel isChannel = is.getChannel();
    //2.字节输出管道
    FileOutputStream os = new FileOutputStream("data4.txt");
    FileChannel osChannel = os.getChannel();
    //3.复制数据
    //osChannel.transferFrom(isChannel,isChannel.position(),isChannel.size());
    isChannel.transferTo(isChannel.position(),isChannel.size(),osChannel);
    isChannel.close();
    osChannel.close();
    System.out.println("使用transferto复制成功！");
}

6. NIO核心三：选择器（Selector)

选择器（Selector）概述

选择器（Selector）是SeIectabIeChannel对象的多路复用器，Selector可以同时监控多个SelectableChannel 的IO状况，也就是说，利用Selector可使一个单独的线程管理多个Channel。

Selector是非阻塞IO的核心

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

选择器（Selector）的应用

创建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(9999));
//4.获取选择器
Selector selector = Selector.open();
//将通道注册到选择器上，并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

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

读： SelectionKey.OP_READ (1)
写： SelectionKey.OP_WRITE (4)
连接： SelectionKey.OP_CONNECT (8)
接收： SelectionKey.OP_ACCEPT (16)
若注册时不止监听一个事件，则可以使用“位或”操作符连接

int interestSet = selectionKey.OP_READ | SelectionKey.OP_WERITE

7. NIO非阻塞式网络通信原理分析

Selector示意图和特点说明

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

服务端流程

当客户端连接服务端时，服务端会通过ServerSocketChannel得到SocketChannel：获取通道

ServerSocketChannel ssChannel = ServerSocketChannel.open();

切换非阻塞模式

ssChannel.configureBlocking(false);

绑定连接

ssChannel.bind(new InetSocketAddress(9999))

获取选择器

Selector selector = Selector.open()

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

ssChannel.register(selector,SelectionKey.OP_ACCEPT);

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

//轮询式的获取选择器上已经“准备就绪”的事件
while(selector.select() > 0){
    System.out.println("轮一轮");
    //7. 获取当前选择器中所有注册的“选择键（已就绪的监听事件）“
    Iterator<SelectionKey> it = selector.selector.selectedKeys().iterator();
    while(it.hasNext()){
       //8.获取准备”就绪“的事件
        SelectionKey sk = it.next();
        //9.判断具体是什么事件准备就绪
        if(sk.isAcceptable()){
            //10.若”接收就绪“，获取客户端连接
            SocketChannel sChannel = ssChannel.accept();
            //11.切换非阻塞模式
            sChannel.configureBlocking(false);
            //12.将该通道注册到选择器上
            sChannel.register(selector,SelectionKey.OP_READ);
        }else if(sk.isReadable()){
            //13.获取当前选择器上”读就绪“状态的通道
            SocketChannel sChannel = (SocketChannel)sk.channel();
            //14.读取数据
            ByteBuffer buf = ByteBuffer.allocate(1024);
            int len = 0;
            while((len = sChannel.read(buf)) > 0){
                buf.flip();
                System.out.println(new String(buf.array(),0,len));
                buf.clear();
            }
        } 
        //15.取消选择键SelectionKey
        it.remove();
    }
}

客户端流程

获取通道

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

切换非阻塞模式

sChannel.configureBlocking(false);

分配指定大小的缓存区

ByteBuffer buf = ByteBuffer.allocate(1024);

发送数据给服务端

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();

8. NIO非阻塞式网络通信入门案例

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

服务端代码

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;
//服务端案例：基于NIO通信模式
public class Server {
    public static void main(String[] args) throws Exception {
        System.out.println("服务端启动...");
        //1.获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        //2.切换为非阻塞模式
        ssChannel.configureBlocking(false);
        //3.绑定连接的端口
        ssChannel.bind(new InetSocketAddress(9999));
        //4.获取选择器
        Selector selector = Selector.open();
        //5.将通道都注册到选择器上去，并且开始指定监听接收事件
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        //6.使用Selector选择器轮询已经就绪好的事件
        while (selector.select()>0){
            //7.获取选择器中的所有注册的通道中已经就序好的事件
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            //8.开始遍历这些准备好的事件
            while (it.hasNext()){
                //提取当前这个事件
                SelectionKey selectionKey = it.next();
                //9.判断这个事件具体是什么事件
                if (selectionKey.isAcceptable()){
                    //10.直接获取当前接入的客户端通道
                    SocketChannel sChannel = ssChannel.accept();
                    sChannel.configureBlocking(false);
                    //12.将客户端通道也注册到选择器Selector上
                    sChannel.register(selector, SelectionKey.OP_READ);
                }else if(selectionKey.isReadable()){
                    //13.获取当前选择器上的”读就绪事件“
                    SocketChannel sChannel = (SocketChannel)selectionKey.channel();
                    //14.开始读取数据
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len=sChannel.read(buf))>0){
                        buf.flip();
                        System.out.println(new String(buf.array(),0,len));
                        buf.clear();//”清除“之前的数据
                    }
                    sChannel.read(buf);
                }
                //处理完毕当前事件后，需要移除掉当前事件.否则会重复处理
                it.remove();
            }
        }
    }
}

客户端代码

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;
//客户端案例：基于NIO通信模式
public class Client {
    public static void main(String[] args) throws Exception {
        //1.获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
        //2.切换为非阻塞模式
        sChannel.configureBlocking(false);
        //3.分配指定缓存区大小
        ByteBuffer buf = ByteBuffer.allocate(1024);
        //4.发送数据给服务端
        Scanner scan = new Scanner(System.in);
        while (true){
            System.out.println("请输入：");
            String msg = scan.nextLine();
            buf.put(("波仔："+msg).getBytes());
            buf.flip();
            sChannel.write(buf);
            buf.clear();
        }
    }
}

9. NIO网络编程应用实例-群聊系统

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

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

服务端代码实现

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.创建选择器
            selector = Selector.open();
            //2.获取通道
            ssChannel = ServerSocketChannel.open();
            //3.切换为非阻塞模式
            ssChannel.configureBlocking(false);
            //4.绑定连接的端口
            ssChannel.bind(new InetSocketAddress(PORT));
            //5.将通道都注册到选择器上去，并且开始指定监听接收事件
            ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        //创建服务端对象
        Server server = new Server();
        //开始监听客户端的各种消息事件：连接、群聊消息、离线消息
        server.listen();
    }
    //监听
    public void listen() {
        //System.out.println("监听线程：" + Thread.currentThread().getName());
        try {
            while (selector.select() > 0){
                //a.获取选择器中所有注册通道的就绪事件
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                //b.开始遍历这个事件
                while (it.hasNext()){
                    //提取这个事件
                    SelectionKey sk = it.next();
                    //c.判断这个事件
                    if(sk.isAcceptable()) {
                        //客户端接入请求
                        //获取当前客户端通道
                        SocketChannel schannel = ssChannel.accept();
                        //注册成非阻塞模式
                        schannel.configureBlocking(false);
                        //注册给选择器，监听读数据的事件
                        schannel.register(selector,SelectionKey.OP_READ);
                    }else if(sk.isReadable()){
                        //处理这个客户端的消息，接收它，然后实现转发逻辑
                        readClientData(sk);
                    }
                    it.remove();//处理完毕之后，需要移除当前事件
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //接收当前客户端的信息，转发给其他全部客户端通道
    private void readClientData(SelectionKey sk) {
        SocketChannel sChannel = null;
        try {
            //直接得到当前客户端通道
            sChannel = (SocketChannel) sk.channel();
            //创建缓存区对象，开始接收客户端通道的数据
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = sChannel.read(buffer);
            if(count > 0) {
                buffer.flip();
                //提取读取到的信息
                String msg = new String(buffer.array(),0,buffer.remaining());
                System.out.println("接收到了客户端的消息：" + msg);
                //把这个消息推送给全部客户端接收
                sendMsgToAllClient(msg,sChannel);
            }
        }catch (Exception e){
            try {
                System.out.println("有人离线了：" + sChannel.getRemoteAddress());
                //当前客户端离线
                sk.cancel();//取消注册
                sChannel.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    //把当前客户端的消息推送给当前全部在线注册的channel
    private void sendMsgToAllClient(String msg, SocketChannel sChannel) throws
            IOException {
        System.out.println("服务端开始转发这个消息，当前处理的线程" + Thread.currentThread().getName());
        for(SelectionKey key : selector.keys()) {
            Channel channel = key.channel();
            //不要把消息发给自己
            if(channel instanceof SocketChannel && channel != sChannel){
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                ((SocketChannel)channel).write(buffer);
            }
        }
    }
}

客户端代码实现

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 {
    //1.定义客户端相关属性
    private Selector selector;
    private static int PORT = 9999;
    private SocketChannel socketChannel;
    //2.初始化客户端信息
    public Client(){
        try {
            //a.创建选择器
            selector = Selector.open();
            //b.连接服务器
            socketChannel = SocketChannel.open(new
                    InetSocketAddress("127.0.0.1",PORT));
            //c.设置非阻塞模式
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_READ);
            System.out.println("当前客户端准备完成");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Client client = new Client();
        //定义一个线程，专门负责监听服务端发送过来的读消息事件
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    client.readInfo();
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }).start();
        //发消息
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()){
            System.out.println("------------------");
            String s = sc.nextLine();
            client.sendToServer(s);
        }
    }
    private void sendToServer(String s) {
        try {
            socketChannel.write(ByteBuffer.wrap(("波仔说：" + s).getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //
    private void readInfo() throws IOException {
        //if(selector.select() > 0){
        while(selector.select() > 0){
            Iterator<SelectionKey> iterator =
                    selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                if(key.isReadable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    sc.read(buffer);
                    System.out.println(new String(buffer.array()).trim());
                    System.out.println("-dsd------------------------");
                }
                iterator.remove();
            }
        }
    }
}

输出

五、JAVA AIO深入剖析

1. AIO编程

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

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

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

AsynchronousSocketChannel
AsynchronousServerSocketChannel
AsynchronousFileChannel
AsynchronousDatagramChannel

六、BIO、NIO、AIO总结

BIO、NIO、AIO

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

BIO、NIO、AIO适用场景分析

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

我的博客：NIO专题（二）
配套代码：gitee仓库

linxc008

关注

30
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
NIO专题（二）

java NlO (New lO）也有人称之为java non-blocking IO，是Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java lO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
复制链接

扫一扫