黑马-NIO

2、Java的io演进之路

2.1io模型基本说明

io模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了通信的性能，Java共支持3种网络编程的io模型：BIO、NIO、AIO

2.2io模型

Java BIO

同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

Java NIO

同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器（selector）上，多路复用器轮训到有io请求就进行处理

Java AIO

Java AIO(NIO2.0)：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的io请求都是由OS先完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

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

1、BIO方式适用于连接数目比较少且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中
2、NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器、弹幕系统、服务器间通讯等
3、AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作

3、Java BIO深入剖析

3.1JavaBIO基本介绍

• Java BIO就是传统的Java io编程，其相关的类和接口在java.io
• BIO（blocking I/O）：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器及需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善

3.2JavaBIO工作机制

服务端和监听客户端，客户端向服务端注册，连接成功就可以进行双向数据传输

3.3传统的BIO编程实例回顾

网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息(绑定IP地址和端口)，客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接,连接成功后，双方通过网络套接字(Socket) 进行通信。

传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址， 启动监听端口;客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。

基于BIO模式下的通信，客户端-服务端是完全同步，完全耦合的。

服务端

public class Server {
    public static void main(String[] args) {

        try {
            System.out.println("===服务端启动===");
            // 1、定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            // 2、监听客户端的socket请求
            Socket socket = ss.accept();
            // 3、从socket管道中得到一个字节输入liu
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            if ((msg = br.readLine()) != null){
                System.out.println("服务端接收到：" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端

public class Client {
    public static void main(String[] args) throws IOException {
        // 1、创建一个socket对象请求服务端的连接
        Socket socket = new Socket("127.0.0.1", 9999);
        // 2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3、把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        ps.println("hello server");
        os.flush();
    }
}

小结

• 在以上通信中，服务端会一直等待客户端的消息，如果客户端没有进行消息的发送，服务端将一直进入阻塞状态
• 同时服务端时按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态
• 端到端的机制，双方任何一方有挂机的情况，对方都会出现异常机制

3.4BIO模式下多发和多收机制

服务端（上述代码改造）

public class Server {
    public static void main(String[] args) {

        try {
            System.out.println("===服务端启动===");
            // 1、定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            // 2、监听客户端的socket请求
            Socket socket = ss.accept();
            // 3、从socket管道中得到一个字节输入liu
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println("服务端接收到：" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端（上述代码改造）

public class Client {
    public static void main(String[] args) throws IOException {
        // 1、创建一个socket对象请求服务端的连接
        Socket socket = new Socket("127.0.0.1", 9999);
        // 2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3、把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            os.flush();
        }
    }
}

3.5BIO模式下接收多个客户端

概述

在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端要处理很多客户端的消息通信请求应该如何处理呢？此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请求，服务端就创建一个新的额线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型

服务端

public class ServerThreadReader extends Thread{

    private Socket socket;

    public ServerThreadReader(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        // 4、从socket管道中得到一个字节输入liu
        InputStream is = null;
        try {
            is = this.socket.getInputStream();
            // 5、把字节输入流包装成一个缓冲字符输入流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println("服务端接收到：" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

public class Server {
    public static void main(String[] args) {

        try {
            System.out.println("===服务端启动===");
            // 1、定义一个ServerSocket对象进行服务端的端口注册
            ServerSocket ss = new ServerSocket(9999);
            while (true) {
                // 2、监听客户端的socket请求
                Socket socket = ss.accept();
                // 3、创建一个独立的线程来处理与这个客户端的socket
                new ServerThreadReader(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端

public class Client {
    public static void main(String[] args) throws IOException {
        // 1、创建一个socket对象请求服务端的连接
        Socket socket = new Socket("127.0.0.1", 9999);
        // 2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3、把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            os.flush();
        }
    }
}

小结

• 每个socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能
• 每个线程都会占用栈空间和CPU资源
• 并不是每个socket都进行IO操作，无意义的线程处理
• 客户端的并发访问增加时，服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务

3.6伪异步IO编程

接下来，采用一个伪异步IO通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task交给后端的线程池处理。

服务端

public class HandlerSocketServerPool {
    // 创建一个线程池的成员变量存储一个线程池对象
    private ExecutorService executor;

    // 创建这个类对象的时候就需要初始化线程池对象
    public HandlerSocketServerPool(int maxThreadNum,int queueSize){
        executor = new ThreadPoolExecutor(
                3,
                maxThreadNum,
                120, 
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));
    }

    // 提供一个方法来提交任务给线程池的任务队列来暂存，等着线程池来处理
    public void execute(Runnable runnable){
        executor.execute(runnable);
    }
}

public class ServerRunnable implements Runnable{

    private Socket socket;

    public ServerRunnable(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        // 处理接收到的socket
        try {
            InputStream inputStream = socket.getInputStream();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String msg;
            if ((msg = bufferedReader.readLine()) != null){
                System.out.println("收到：" + msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

public class SyncServer {
    public static void main(String[] args) {
        try {
            // 注册端口
            ServerSocket ss = new ServerSocket(9999);
            // 定义一个循环接收客户端的socket请求，同时初始化线程池对象
            HandlerSocketServerPool pool = new HandlerSocketServerPool(6, 10);
            while (true){
                Socket socket = ss.accept();
                // 把socket对象交给一个线程池进行处理
                ServerRunnable serverRunnable = new ServerRunnable(socket);
                pool.execute(serverRunnable);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端

public class Client {
    public static void main(String[] args) throws IOException {
        // 1、创建一个socket对象请求服务端的连接
        Socket socket = new Socket("127.0.0.1", 9999);
        // 2、从socket对象中获取一个字节输出流
        OutputStream os = socket.getOutputStream();
        // 3、把字节输出流包装成一个打印流
        PrintStream ps = new PrintStream(os);
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.print("请说：");
            String msg = sc.nextLine();
            ps.println(msg);
            os.flush();
        }
    }
}

小结

• 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立的新城造成资源耗尽的问题，但由于底层依然采用的是同步阻塞模型，因此无法从根本上说那个解决问题
• 如果单个消息处理的缓慢，或者线程池中的全部线程都被阻塞，那么后续socket的io消息都将在队列中排队。新socket请求将被拒绝。

4、Java NIO深入剖析

4.1Java BIO基本介绍

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

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

• Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此， 一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。

通俗理解: NIO是可以做到用一个线程来处理多个操作的。假设有1000个请求过来根据实际情况，可以分配20或者80个线程来处理。不像之前的阻塞10那样,非得分配1000个。

4.2NIO和BIO的比较

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

NIO	BIO
面向缓冲区（Buffer）	面向流（Stream）
非阻塞IO（Non Blocking IO）	阻塞IO（Blocking IO）
选择器（Selectors）

4.3NIO三大核心原理示意图

NIO有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）

Buffer（缓冲区）

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便得访问该块内存。

Channel（通道）

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

Selector（选择器）

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

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

4.4NIO核心一：缓冲区（buffer）

缓冲区（buffer）

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

Buffer类及其子类

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

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

缓冲区的基本属性

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

Buffer常见方法

缓冲区的数据操作

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

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

    @Test
    public void test(){
        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("-------------------------------");
        // put往缓冲区添加数据
        String name = "itheima";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());// 7
        System.out.println(buffer.limit());// 10
        System.out.println(buffer.capacity());// 10
        System.out.println("-------------------------------");
        // flip()为缓冲区的界限设置为当前位置，并将当前位置设置为0。其实就是切换为可读模式，因为limit之后的数据都是为空的
        buffer.flip();
        System.out.println(buffer.position());// 0
        System.out.println(buffer.limit());// 7
        System.out.println(buffer.capacity());// 10
        System.out.println("-------------------------------");
        // get数据的读取
        char b = (char) buffer.get();
        System.out.println(b);
        System.out.println(buffer.position());// 1
        System.out.println(buffer.limit());// 7
        System.out.println(buffer.capacity());// 10
    }

@Test
    public void test2(){
        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("-------------------------------");
        // put往缓冲区添加数据
        String name = "itheima";
        buffer.put(name.getBytes());
        System.out.println(buffer.position());// 7
        System.out.println(buffer.limit());// 10
        System.out.println(buffer.capacity());// 10
        System.out.println("-------------------------------");
        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()));// 清除之后，发现返回的居然还是i，clear()只是让position和limit回到0，之后再添加数据才会覆盖之前的数据
        System.out.println("-------------------------------");

        // 定义一个缓冲区
        ByteBuffer buf = ByteBuffer.allocate(10);
        String n = "itheima";
        buf.put(n.getBytes());

        buf.flip();

        // 读取数据
        byte[] b  = new byte[2];
        buf.get(b);
        String rs = new String(b);
        System.out.println(rs);
        System.out.println(buf.position());// 2
        System.out.println(buf.limit());// 7
        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));
        System.out.println(buf.position());// 5
        System.out.println(buf.limit());// 7
        System.out.println(buf.capacity());// 10
        System.out.println("-------------------------------");
        buf.reset();
        if (buf.hasRemaining()){
            System.out.println(buf.remaining());
        }
        System.out.println(buf.position());// 5
        System.out.println(buf.limit());// 7
        System.out.println(buf.capacity());// 10
    }

直接与非直接缓冲区

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

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

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

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

而直接内存是

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

很明显，在做IO处理时，比如网络发送大量数据，直接内存会具有更高的效率。不过这部分的数据是在JVM之外的，因此他不会占用应用内存。

@Test
    public void test3(){
        // 申请一块直接内存
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        System.out.println(buffer.isDirect());
    }

4.5NIO核心二：通道（Channel）

通道（Channel）概述

通道（Channel）：由java.nio.channels包定义。channel表示IO源与目标打开的连接。Channel类似于传统的“流”，只不过Channel本身补鞥直接访问数据，只能与Buffer进行交互。
1、NIO的通道类似于流，但有些区别如下：

• 通道可以同时进行读写，而流只能读或者写
• 通道可以实现异步读写数据
• 通道可以从缓冲读数据，也可以写数据到缓冲
  2、BIO中的流是单向的，而NIO中的通道是双向的，可以读也可以写
  3、Channel在NIO中是一个接口

public interface Channel extends Closeable{}

常用的Channel实现类

FileChannel类

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

FileChannel的常用方法

案例1-本地文件写数据

需求：使用前面学习的ByteBuffer（缓冲）和FileChannel（通道），将“人生贵在有追求，哪怕脚下路悠悠”写入到data01.txt中。

@Test
    public void test() {
        try {
            // 字节输出流，通向目标文件
            FileOutputStream fos = new FileOutputStream("data01.txt");
            // 得到字节输出流对应的channel
            FileChannel channel = fos.getChannel();
            // 分配缓冲区（因为通道不能直接读写数据，必须通过缓冲区）
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            // 往缓冲区里面塞数据
            buffer.put("人生贵在有追求，哪怕脚下路悠悠".getBytes());
            // 把缓冲区切换成写出模式
            buffer.flip();
            channel.write(buffer);
            channel.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

案例2-本地文件读数据

将上一步写入的文件读取出来，打印在控制台

@Test
    public void test2() throws IOException {
        try {
            FileInputStream fis = new FileInputStream("data01.txt");
            FileChannel channel = fis.getChannel();

            ByteBuffer buffer = ByteBuffer.allocate(1024);
            // 读取数据到换乘区
            channel.read(buffer);
            // 将position归位
            buffer.flip();
            // 读取出缓冲区的数据并输出
            String s = new String(buffer.array(), 0, buffer.limit());
            System.out.println(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

案例-4分散（Scatter）和聚集（Gather）

分散读取：指把Channel通道的数据读入到多个缓冲区中区
聚集写入：值将多个Buffer中的数据聚集到Channel

@Test
    public void test3() throws IOException {
        FileInputStream is = new FileInputStream("data01.txt");
        FileChannel isChannel = is.getChannel();

        FileOutputStream fos = new FileOutputStream("data02.txt");
        FileChannel fosChannel = fos.getChannel();

        // 定义多个缓冲区做数据分散
        ByteBuffer buffer1 = ByteBuffer.allocate(8);
        ByteBuffer buffer2= ByteBuffer.allocate(1024);
        ByteBuffer[] buffers = {buffer1,buffer2};

        // 从通道中读取数据分散到各个缓冲区
        isChannel.read(buffers);
        // 分散：从每个缓冲区读取数据
        for (ByteBuffer buffer : buffers) {
            buffer.flip();
            System.out.println(new String(buffer.array(),0,buffer.remaining()));
        }

        // 聚集：聚集写入到通道
        fosChannel.write(buffers);
        isChannel.close();
        fosChannel.close();
    }

5-transferFrom()

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

@Test
    public void test4() throws IOException {
        FileInputStream fis = new FileInputStream("data01.txt");
        FileChannel fisChannel = fis.getChannel();

        FileOutputStream fos = new FileOutputStream("data03.txt");
        FileChannel fosChannel = fos.getChannel();

        // 复制
        fosChannel.transferFrom(fisChannel,fisChannel.position(),fisChannel.size());

        fisChannel.close();
        fosChannel.close();

    }

6-transformTo()

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

@Test
    public void test5() throws IOException {
        FileInputStream fis = new FileInputStream("data01.txt");
        FileChannel fisChannel = fis.getChannel();

        FileOutputStream fos = new FileOutputStream("data04.txt");
        FileChannel fosChannel = fos.getChannel();

        // 复制
        fisChannel.transferTo(fisChannel.position(),fisChannel.size(),fosChannel);

        fisChannel.close();
        fosChannel.close();

    }

4.6NIO核心三：选择器（Selector）

选择器（Selector）概述

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

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

Selector示意图和特点说明

选择器（Selector）的应用

创建Selector：通过Selector.open()方法创建一个Selector

Selector selector = Selector.open();

向选择器注册通道：

SelectableChannel.register(Selector sel,int ops)

当调用register(Selector sel,int ops)将通道注册选到择器时，选择器对通道的监听事件，需要通过第二个参数指定。可以监听的事件类型如下：

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

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

Selector示意图好特点说明

Selector可以实现一个IO线程并发处理N个客户端连接和读写操作，这从根本上解决了传统阻塞式IO一个连接一个线程的模型。

服务端流程

1、当客户端连接服务端时，服务端会通过ServerSocketChannel得到SocketChannel

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、轮询式获取选择器上已经就绪的事件

客户端流程

1、获取通道

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

2、切换非阻塞模式

sChannel.configureBlocking(false);

3、分配制定大小的缓冲区

ByteBuffer buf = ByteBuffer.allocate(1024);

4、发送数据给服务端

服务端示例

public class NIOServer {
    public static void main(String[] args) throws IOException {
        System.out.println("----------服务端启动----------");
        // 获取通道
        ServerSocketChannel ssChannel = ServerSocketChannel.open();
        // 切换为非阻塞模式
        ssChannel.configureBlocking(false);
        // 绑定连接的端口
        ssChannel.bind(new InetSocketAddress(9999));
        // 获取选择器
        Selector selector = Selector.open();
        // 将通道注册到选择器，并且开始制定监听接收事件
        ssChannel.register(selector, SelectionKey.OP_ACCEPT);
        // 使用selector选择器轮询已经就绪好的事件
        while (selector.select() > 0) {
            // 获取选择器中的所有注册的通道中已经就绪好的事件
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            // 开始遍历准备好的事件
            while (it.hasNext()) {
                // 提取这个事件
                SelectionKey sk = it.next();
                // 判断这个事件具体是什么
                if (sk.isAcceptable()) {
                    // 直接获取当前接入的客户端通道
                    SocketChannel sChannel = ssChannel.accept();
                    // 切换为非阻塞模式
                    sChannel.configureBlocking(false);
                    // 将本客户端通道注册到选择器
                    sChannel.register(selector, SelectionKey.OP_READ);
                } else if (sk.isReadable()) {
                    // 获取当前选择器上的读的就绪的事件
                    SocketChannel channel = (SocketChannel) sk.channel();
                    // 读取数据
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    int len = 0;
                    while ((len = channel.read(buf)) > 0) {
                        buf.flip();
                        System.out.println(new String(buf.array(), 0, len));
                        // 清除之前的数据
                        buf.clear();
                    }
                }
                // 处理完毕的事件需要移除
                it.remove();
            }
        }
    }
}

客户端示例

public class NIOClient {
    public static void main(String[] args) throws IOException {
        // 获取通道
        SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9999));
        // 切换成非阻塞模式
        sChannel.configureBlocking(false);
        // 分配缓冲区大小
        ByteBuffer buf = ByteBuffer.allocate(1024);
        // 发送数据给服务端
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.print("请说：");
            String msg = scanner.nextLine();
            buf.put(("赛尔号：" + msg).getBytes());
            buf.flip();
            // 将缓冲区数据写进通道
            sChannel.write(buf);
            buf.clear();
        }
    }
}

5、AIO

5.1AIO编程

Java AIO：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的IO请求都是由OS先完成了再通知服务器应用去启动线程进行处理

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

可以理解为：read/write方法都是异步得，完成后会主动调用回调函数。