操作系统中的 I/O
      以上是 Java 对操作系统的各种 IO 模型的封装，【文件的输入、输出】在文件处理时，其实依赖操作系统层面的 IO 操作实现的。【把磁盘的数据读到内存种】操作系统中的 IO 有 5 种：
阻塞、
非阻塞、【轮询】
异步、
IO复用、【多个进程的 IO 注册到管道上】
信号驱动 IO
 

1.传统的IO流会进行阻塞操作、一个字节一个字节操作
2.NIO提供了一个区域块的 数据映射、 异步的IO流操作
3.通道是 用于获取流中数据 ===>【channel获取的是传统IO流中的数据，读写】
4.缓冲区是 用于保存通道中的数据- ===>【buffer获取的是channel中的数据，读写】

 传统IO操作请看IO操作
IO和NIO的区别
IO:1.面向流（Stream） 2.阻塞IO（Blocking IO）
NIO:1.面向缓冲区 2.非阻塞IO（NO Blocking IO）3. 选择器（Selectors）

（一）引言
IO流是Java中比较难理解的一个知识点，但是IO流在实际的开发场景中经常会使用到，比如Dubbo底层就是NIO进行通讯。本文将介绍Java发展过程中出现的三种IO：BIO、NIO以及AIO，重点介绍NIO。

（二）什么是BIO
BIO即同步阻塞IO，实现模型为一个连接就需要一个线程去处理。这种方式简单来说就是当有客户端来请求服务器时，服务器就会开启一个线程去处理这个请求，即使这个请求不干任何事情，这个线程都一直处于阻塞状态。

BIO模型有很多缺点，最大的缺点就是资源的浪费。想象一下如果QQ使用BIO模型，当有一个人上线时就需要一个线程，即使这个人不聊天，这个线程也一直被占用，那再多的服务器资源都不管用。

同步： 同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。
异步： 异步就是发起一个调用后，立刻得到被调用者的回应表示已接收到请求，但是被调用者并没有返回结果，此时可以处理其他的请求，被调用者通常依靠事件，回调等机制来通知调用者其返回结果。
同步和异步的区别最大在于 异步调用者不需要等待处理结果，被调用者会通过回调等机制来通知调用者其返回结果。
阻塞： 阻塞就是发起一个请求，调用者一直等待请求结果返回，也就是当前线程会被挂起，无法从事其他任务，只有当条件就绪才能继续。
非阻塞： 非阻塞就是发起一个请求，调用者不用一直等着结果返回，可以先去干其他事情。
 

 BIO (Blocking I/O) 同步阻塞
     服务端创建一个 ServerSocket ， 然后就是客户端用一个Socket 去连接服务端的那个 ServerSocket， ServerSocket 接收到了一个的连接请求就创建一个Socket和一个线程去跟那个 Socket 进行通讯。接着客户端和服务端就进行阻塞式的通信，客户端发送一个请求，服务端 Socket 进行处理后返回响应，在响应返回前，客户端那边就阻塞等待，什么事情也做不了。
     这种方式的缺点， 每次一个客户端接入，都需要在服务端创建一个线程来服务这个客户端，这样大量客户端来的时候，就会造成服务端的线程数量可能达到了几千甚至几万，这样就可能会造成服务端过载过高，最后崩溃死掉。

（三）BIO代码实践

我们通过socket模拟BIO的实现逻辑

首先建立Server，建立一个ServerSocket对象，绑定端口，然后等待连接，如果连接成功就新建一个线程去处理连接。

server服务端：两种情况：

1.单线程处理多个客户端

2.多线程处理多个客户端 ,也就是服务端接受到客户端的socket就开启一个线程去处理.

package com.cn.jettech.jettoproimage.controller.imagecontroller01.imagecontroller01.io.bio;


import java.io.IOException;
import java.net.*;

/**
 * BIO即同步阻塞IO，实现模型为一个连接就需要一个线程去处理
 *
 **/
public class BIOServer {
    private static Socket socket = null;
    private static int thread_queue_size = 100;
    private static volatile int i = 0;
    private static int server_port = 8080;
    private static String server_ip = "192.168.0.17";
    public static void main(String[] args) throws  Exception{
        //ServerSocket serverSocket = new ServerSocket(BIOServer.server_port,BIOServer.thread_queue_size,InetAddress.getByName(BIOServer.server_ip));
        ServerSocket serverSocket = new ServerSocket();
        //该选项用来决定如果网络上仍然有数据向旧的ServerSocket传输数据，是否允许新的ServerSocket绑定到与旧的ServerSocket同样的端口上，
        //该选项的默认值与操作系统有关，在某些操作系统中，允许重用端口，而在某些系统中不允许重用端口。
        //当ServerSocket关闭时，如果网络上还有发送到这个serversocket上的数据，这个ServerSocket不会立即释放本地端口，
        //而是等待一段时间，确保接收到了网络上发送过来的延迟数据，然后再释放端口。
        //值得注意的是，public void setReuseAddress(boolean on) throws SocketException必须在ServerSocket还没有绑定到一个本地端口之前使用，
        //否则执行该方法无效。此外，两个公用同一个端口的进程必须都调用serverSocket.setReuseAddress(true)方法，才能使得一个进程关闭ServerSocket之后，
        //另一个进程的ServerSocket还能够立刻重用相同的端口。
        //serverSocket.setReuseAddress(true);
        //SO_RCVBUF 表示 Socket 的用于输入数据的缓冲区的大小. 一般说来, 传输大的连续的数据块(基于HTTP 或 FTP 协议的通信) 可以使用较大的缓冲区,
        //这可以减少传输数据的次数, 提高传输数据的效率. 而对于交互频繁且单次传送数据量比较小的通信方式(Telnet 和 网络游戏), 则应该采用小的缓冲区,
        //确保小批量的数据能及时发送给对方. 这种设定缓冲区大小的原则也同样适用于 Socket 的 SO_SNDBUF 选项.
        //serverSocket.setReceiveBufferSize(10000);
        //SO_TIMEOUT表示ServerSocket的accept()方法等待客户连接的超时时间，以毫秒为单位。如果SO_TIMEOUT的值为0，表示永远不会超时，这是SO_TIMEOUT的默认值。
        //当服务器执行ServerSocket的accept()方法时，如果连接请求队列为空，服务器就会一直等待，直到接收到了客户连接才从accept()方法返回。如果设定了超时时间，
        //那么当服务器等待的时间超过了超时时间，就会抛出SocketTimeoutException，它是InterruptedException的子类。
        //当底层的Socket实现不支持SO_TIMEOUT选项时，这两个方法将抛出SocketException例外。不能将timeout设为负数，
        //否则setSoTimeout方法将抛出IllegalArgumentException例外。
        //serverSocket.setSoTimeout(10000);
        //backlog : 输入连接指示（对连接的请求）的最大队列长度被设置为 backlog 参数。如果队列满时收到连接指示，则拒绝该连接。
        //1. backlog参数必须是大于 0 的正值。如果传递的值等于或小于 0，则假定为默认值。
        //2. 经过测试这个队列是按照FIFO（先进先出）的原则。
        //3. 如果将accept这个函数放在一个循环体中时，backlog参数也不会有什么作用。或者简单的讲运行ServerSocket的这个线程会阻塞时，无论是在accept，还是在read处阻塞，这个backlog参数才生效。
        serverSocket.bind(new InetSocketAddress(BIOServer.server_port),BIOServer.thread_queue_size);
//        System.out.println(serverSocket.isBound() && !serverSocket.isClosed());
//        if(serverSocket.isBound()) {
//            System.out.println(serverSocket.getLocalPort());
//            System.out.println(serverSocket.getInetAddress().getHostAddress());
//        }
        while (true) {
            //等待连接  阻塞
            ++i;
            System.out.println("等待客户端的连接");
            socket = serverSocket.accept();
            System.out.println("服务端已经获取到了客户端你的第"+i+"个socket，连接成功"+socket.getRemoteSocketAddress());
            try {
                Thread.sleep(1000); //thread_queue_size参数是模拟请求的队列池子大小---单线程模式下，这样客户端请求过大服务器不予处理。
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //System.in.read();
            //Thread thread= new Thread(new MyRun(socket));  //多线程处理客户端
            //thread.start();
        }
    }
}
class MyRun implements  Runnable {
    private Socket socket;
    public MyRun(Socket socket) {
        this.socket = socket;
    }
    public MyRun() {
    }
    public void run() {
        byte[] bytes=new byte[33];
        try {
            System.out.println("服务端等待读数据");
            int length=socket.getInputStream().read(bytes);
            System.out.println("读到客户端传过来的数据的长度是:" +length);
//            System.out.println("服务端每次处理的最大数据是:" +bytes.length);
//            System.out.println("============第一段"+new String(bytes,0,6)+"=============");
            System.out.println("======"+Thread.currentThread().getName()+"======读取整体"+new String(bytes,0,length)+"=============");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                socket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

client客户端：属于真正的客户端，因为数多线程模拟的客户端

package com.cn.jettech.jettoproimage.controller.imagecontroller01.imagecontroller01.io.bio;
import java.io.IOException;
import java.net.Socket;
public class BIOClient {
    private static int socket_size = 100;
    private static int server_port = 8080;
    private static String server_ip = "192.168.0.17";
    public static void main(String[] args) throws Exception{
        Socket[] client = new Socket[BIOClient.socket_size];
        for (int i = 0; i < BIOClient.socket_size; i++) {
            final int index = i;
            new Thread(()->{
                try {
                    client[index] = new Socket(BIOClient.server_ip,BIOClient.server_port);
//                    client[index].getOutputStream().write("我是第".getBytes());
//                    client[index].getOutputStream().write(index);
//                    client[index].getOutputStream().write("客户端过来的数据".getBytes());
                    System.out.println("第 " + (index+1) + "客户端连接成功");
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            },String.valueOf(i)).start();
        }
    }
}

BIO是阻塞的，如果没有多线程，BIO就需要一直占用CPU，而NIO则是非阻塞IO，NIO在获取连接或者请求时，即使没有取得连接和数据，也不会阻塞程序。NIO的服务器实现模式为一个线程可以处理多个请求（连接）。也就是说BIO服务端多线程也可以处理多个客户端，但是这样服务端线程数量会增多性能会下降。

（四）什么是NIO
BIO是阻塞的，如果没有多线程，BIO就需要一直占用CPU，而NIO则是非阻塞IO，NIO在获取连接或者请求时，即使没有取得连接和数据，也不会阻塞程序。NIO的服务器实现模式为一个线程可以处理多个请求（连接）。

NIO有几个知识点需要掌握，Channel(通道)，Buffer(缓冲区), Selector（多路复用选择器）。

Channel既可以用来进行读操作，又可以用来进行写操作。NIO中常用的Channel有FileChannel
、SocketChannel、ServerSocketChannel、DatagramChannel。

Buffer缓冲区用来发送和接受数据。

Selector 一般称为选择器或者多路复用器 。它是Java NIO核心组件中的一个，用于检查一个或多个NIO Channel（通道）的状态是否处于可读、可写。在javaNIO中使用Selector往往是将Channel注册到Selector中。

下面我通过代码的方式模拟javaNIO的运行流程。

（五）NIO代码实践
首先贴上NIO的实践代码：

NIO服务端详细的执行过程是这样的：

1、创建一个ServerSocketChannel和Selector，然后将ServerSocketChannel注册到Selector上

2、Selector通过select方法去轮询监听channel事件，如果有客户端要连接时，监听到连接事件。

3、通过channel方法将socketchannel绑定到ServerSocketChannel上，绑定通过SelectorKey实现。

4、socketchannel注册到Selector上，关心读事件。

5、Selector通过select方法去轮询监听channel事件，当监听到有读事件时，ServerSocketChannel通过绑定的SelectorKey定位到具体的channel，读取里面的数据。