IO模型

1. socket网络编程

　　socket套接字是两台主机之间的逻辑连接的端点，TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，HTTP是应用层协议，主要解决如何包装数据。socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元，是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的ip地址、本地进程的协议端口、远程主机的ip地址、远程进程的协议端口。

　　socket整体流程：主要设计客户端和服务端两个方面，首先是在服务器端创建一个服务器套接字（ServerSocket），并把它附加到一个端口上，服务器从这个端口监听连接，端口号的范围是0到65536，但是0到1024是为特权服务保留的端口号，可以选择任意一个当前没有被其他进程使用的端口。

　　客户端请求与服务器进行连接的时候，根据服务器的域名或ip地址，加上端口号，打开一个套接字，当服务器接受连接后，服务器和客户端之间的通信就像输入输出流一样进行操作。

2. I/O模型

　　I/O模型就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。

　　java共支持3种网络编程模型I/O模式：BIO(同步并阻塞)、NIO（同步非阻塞）、AIO（异步非阻塞）

　　阻塞和非阻塞：主要指的是访问I/O的线程是否会阻塞（或处于等待）；线程访问资源该资源是否准备就绪的一种处理方式。

　　同步和异步：主要指数据的请求方式，同步和异步是指访问数据的一种机制。

2.1 BIO

　　服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通信线程池改善。

　　问题：

　　每个请求都需要创建独立的线程，与对应的客户端进行数据read，业务处理，数据write。

　　并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。

　　连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在read操作上，造成线程资源浪费。

2.2 NIO

　　服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理。

 

2.3 AIO

　　引用异步通道的概念，采用了Proactor模式（通知的不是就绪事件，而是操作完成事件），简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

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

　　BIO适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中。

　　NIO适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。

　　AIO适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作。

3. NIO编程

　　三大核心：channel（通道）、Buffer(缓冲区)、Selector（选择器）。

　　NIO是面向缓冲区编程的，数据读取到一个缓冲区中，需要时可在缓冲区前后移动，增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩网络。

　　一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他得到事情，NIO可以用一个线程来处理多个操作的，假设有10000个请求过来，根据实际情况，可以分配50或者100个线程来处理。

　　BIO以流的方法处理数据，基于字节流和字符流进行操作，NIO以缓冲区的方式处理数据，基于通道和缓冲区进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写到通道中，选择器用于监听多个通道的事件（比如:连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。

　　

 

 每个channel都会对应一个buffer。

selector对应一个线程，一个线程对应多个channel（连接）。

每个channel都注册到selector选择器上。

selector不断轮询查看channel上的事件。

selector会根据不同的事件，完成不同的处理操作。

buffer就是一个内存块，底层是有一个数组。

数据的读取写入是通过buffer，BIO中要么是输入流或者是输出流，不能双向，但是NIO的buffer是可以读也可以写，channel是双向的。

3.1 缓冲区

　　本质上是一个可以读写数据的内存块，可以理解为一个数组，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，channel提供从网络读取数据的渠道，但是读取或写入的数据都必须经由buffer。

 

 Buffer是一个顶层父类，是一个抽象类，常用的缓冲区分别对应byte、short、int、long、float、double、char.

缓冲区对象创建有allocate（创建byte类型的指定长度的缓冲区）和wrap（创建一个有内容的byte类型缓冲区）

 //1.创建指定长度的缓冲区  ByteBuffer为例
        ByteBuffer allocate = ByteBuffer.allocate(5);
        for (int i = 0; i < 5; i++) {
            System.out.println(allocate.get());//从缓冲区当中拿去数据
        }
        //会报错
        //System.out.println(allocate.get());//从缓冲区当中拿去数据

        //2.创建一个有内容的缓冲区
        ByteBuffer wrap = ByteBuffer.wrap("test".getBytes());
        for (int i = 0; i < 4; i++) {
            System.out.println(wrap.get());
        }

往缓冲区添加数据

//1.创建一个缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        System.out.println(allocate.position());//0 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//10 还有多少个可以操作的个数

        System.out.println("----------------");

        // 添加一个字节
        allocate.put((byte) 97);
        System.out.println(allocate.position());//1 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//9 还有多少个可以操作的个数
     //如果缓冲区满了. 可以调整position位置, 就可以重复写. 会覆盖之前存入索引位置的值
        allocate.position(0);
        allocate.put("123456".getBytes());
        System.out.println(allocate.position());//6 获取当前索引所在位置
        System.out.println(allocate.limit());//10 最多能操作到哪个索引位置
        System.out.println(allocate.capacity());//10 返回缓冲区总长度
        System.out.println(allocate.remaining());//4 还有多少个可以操作的个数
        System.out.println(allocate.hasRemaining());//true 是否还能操作    

缓冲区读取数据

        //1.创建一个指定长度的缓冲区
        ByteBuffer allocate = ByteBuffer.allocate(10);
        allocate.put("0123".getBytes());
        System.out.println("position:" + allocate.position());//4
        System.out.println("limit:" + allocate.limit());//10
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6

        //切换读模式
        System.out.println("读取数据--------------");
        allocate.flip();
        System.out.println("position:" + allocate.position());//4
        System.out.println("limit:" + allocate.limit());//10
        System.out.println("capacity:" + allocate.capacity());//10
        System.out.println("remaining:" + allocate.remaining());//6
        for (int i = 0; i < allocate.limit(); i++) {
            System.out.println(allocate.get());
        }
        //读取完毕后.继续读取会报错,超过limit值
        //System.out.println(allocate.get());
        //读取指定索引字节
        System.out.println("读取指定索引字节--------------");
        System.out.println(allocate.get(1));

        System.out.println("读取多个字节--------------");
        // 重复读取
        allocate.rewind();
        byte[] bytes = new byte[4];
        allocate.get(bytes);
        System.out.println(new String(bytes));

        // 将缓冲区转化字节数组返回
        System.out.println("将缓冲区转化字节数组返回--------------");
        byte[] array = allocate.array();
        System.out.println(new String(array));

        // 切换写模式,覆盖之前索引所在位置的值
        System.out.println("写模式--------------");
        allocate.clear();
        allocate.put("abc".getBytes());
        System.out.println(new String(allocate.array()));

3.2 通道

　　通常来说NIO的所有IO都是从通道开始的，NIO的通道类似于流，但是通道可以读也可以写，可以异步读写，总是基于缓冲区buffer来读写。

　　常用的channel实现类有：FileChannel （用于文件的数据读写）,  DatagramChannel （用于UDP的数据读写）,ServerSocketChannel和SocketChannel（用于TCP的数据读写）。

使用通道实现客户端和服务器间的通信。

服务器代码

        //1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务端启动成功....");
        while (true) {
            //4. 检查是否有客户端连接 有客户端连接会返回对应的通道
            SocketChannel socketChannel = serverSocketChannel.accept();
            if (socketChannel == null) {
                System.out.println("没有客户端连接...我去做别的事情");
                Thread.sleep(2000);
                continue;
            }
            //5. 获取客户端传递过来的数据,并把数据放在byteBuffer这个缓冲区中
            ByteBuffer allocate = ByteBuffer.allocate(1024);
            //返回值
            //正数: 表示本地读到有效字节数
            //0: 表示本次没有读到数据
            //-1: 表示读到末尾
            int read = socketChannel.read(allocate);
            System.out.println("客户端消息:" + new String(allocate.array(), 0,
                    read, StandardCharsets.UTF_8));
            //6. 给客户端回写数据
            socketChannel.write(ByteBuffer.wrap("你好".getBytes(StandardCharsets.UTF_8)));
            //7. 释放资源
            socketChannel.close();
        }

客户端代码：

//1. 打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2. 设置连接IP和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9999));
        //3. 写出数据
        socketChannel.write(ByteBuffer.wrap("你好!".getBytes(StandardCharsets.UTF_8)));
        //4. 读取服务器写回的数据
        ByteBuffer allocate = ByteBuffer.allocate(1024);
        int read = socketChannel.read(allocate);
        System.out.println("服务端消息:" +
                new String(allocate.array(), 0, read, StandardCharsets.UTF_8));
        //5. 释放资源
        socketChannel.close();

3.3选择器

　　选择器能够检测多个注册的服务端通道上是否有事件发生，如有事件 发生，便获取事件，进行相应处理，这样就可以只用一个线程去管理多个通道，也就是管理多个连接和请求。

 

 

常用方法:

Selector.open() : //得到一个选择器对象

selector.select() : //阻塞 监控所有注册的通道,当有对应的事件操作时, 会将SelectionKey放入 集合内部并返回事件数量

selector.select(1000): //阻塞 1000 毫秒，监控所有注册的通道,当有对应的事件操作时, 会将 SelectionKey放入集合内部并返回
selector.selectedKeys() : // 返回存有SelectionKey的集合

常用方法

SelectionKey.isAcceptable():  是否是连接继续事件

SelectionKey.isConnectable():  是否是连接就绪事件

SelectionKey.isReadable():  是否是读就绪事件

SelectionKey.isWritable():  是否是写就绪事件

SelectionKey中定义的4种事件:

SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，服务器 可以接收这个连接了 SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户端与服务器的连接已经建立成功 SelectionKey.OP_READ —— 读就绪事件，表示通道中已经有了可读的数据，可以执行读操 作了（通道目前有数据，可以进行读操作了）

SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可以用 于写操作

　selector编码：

        //1. 打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2. 绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //3. 通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //4. 创建选择器
        Selector selector = Selector.open();
        //5. 将服务端通道注册到选择器上,并指定注册监听的事件为OP_ACCEPT
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务端启动成功.....");
        while (true) {
            //6. 检查选择器是否有事件
            int select = selector.select(2000);
            if (select == 0) {
                System.out.println("没有事件发生....");
                continue;
            }
            //7. 获取事件集合
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                //8. 判断事件是否是客户端连接事件SelectionKey.isAcceptable()
                SelectionKey key = iterator.next();
                if (key.isAcceptable()) {
                    //9. 得到客户端通道,并将通道注册到选择器上, 并指定监听事件为OP_READ
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("有客户端连接.....");
                    //将通道必须设置成非阻塞的状态.因为selector选择器需要轮询监听每个通道的事件
                    socketChannel.configureBlocking(false);
                    //指定监听事件为OP_READ 读就绪事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }
                //10. 判断是否是客户端读就绪事件SelectionKey.isReadable()
                if (key.isReadable()) {
                    //11.得到客户端通道,读取数据到缓冲区
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer allocate = ByteBuffer.allocate(1024);
                    int read = socketChannel.read(allocate);
                    if (read > 0) {
                        System.out.println("客户端消息:" + new String(allocate.array(), 0, read
                                , StandardCharsets.UTF_8));
                        //12. 给客户端回写数据
                        socketChannel.write(ByteBuffer.wrap("你好".getBytes(StandardCharsets.UTF_8)));
                        socketChannel.close();
                    }
                }
                //13. 从集合中删除对应的事件, 因为防止二次处理.
                iterator.remove();
            }
        }