BIO\NIO\AIO和对应网络编程的发展

野性酷女 2024-04-19 16:02 72阅读 0赞

传统的io为bio(blocking i/o),阻塞io;使用bio的网络编程经典方式如下:  
\{  
 ExecutorService executor = Excutors.newFixedThreadPollExecutor(100);//线程池  
 ServerSocket serverSocket = new ServerSocket();  
 serverSocket.bind(8088);  
 while(!Thread.currentThread.isInturrupted())\{//主线程死循环等待新连接到来  
 Socket socket = serverSocket.accept();  
 executor.submit(new ConnectIOnHandler(socket));//为新的连接创建新的线程  
\}

class ConnectIOnHandler extends Thread\{  
    private Socket socket;  
    public ConnectIOnHandler(Socket socket)\{  
       this.socket = socket;  
    \}  
    public void run()\{  
      while(!Thread.currentThread.isInturrupted()&&!socket.isClosed())\{死循环处理读写事件  
          String someThing = socket.read()....//读取数据  
          if(someThing!=null)\{  
             ......//处理数据  
             socket.write()....//写数据  
          \}  
       \}  
    \}  
\}

经典的每连接每线程的模型，之所以使用多线程，主要原因在于socket.accept()、socket.read()、socket.write()三个主要函数都是同步阻塞的，当一个连接在处理I/O的时候，系统是阻塞的，如果是单线程的话必然就挂死在那里；但CPU是被释放出来的，开启多线程，就可以让CPU去处理更多的事情。其实这也是所有使用多线程的本质：  
1)利用多核。  
2)当I/O阻塞系统，但CPU空闲的时候，可以利用多线程使用CPU资源。  
现在的多线程一般都使用线程池，可以让线程的创建和回收成本相对较低。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的I/O并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。

不过，这个模型最本质的问题在于，严重依赖于线程。但线程是很"贵"的资源，主要表现在：  
a、线程的创建和销毁成本很高，在Linux这样的操作系统中，线程本质上就是一个进程。创建和销毁都是重量级的系统函数。  
b、线程本身占用较大内存，像Java的线程栈，一般至少分配512K～1M的空间，如果系统中的线程数过千，恐怕整个JVM的内存都会被吃掉一半。  
c、线程的切换成本是很高的。操作系统发生线程切换的时候，需要保留线程的上下文，然后执行系统调用。如果线程数过高，可能执行线程切换的时间甚至会大于线程执行的时间，这时候带来的表现往往是系统load偏高、CPU sy使用率特别高（超过20%以上)，导致系统几乎陷入不可用的状态。  
d、容易造成锯齿状的系统负载。因为系统负载是用活动线程数或CPU核心数，一旦线程数量高但外部网络环境不是很稳定，就很容易造成大量请求的结果同时返回，激活大量阻塞线程从而使系统负载压力过大。

所以，当面对十万甚至百万级连接的时候，传统的BIO模型是无能为力的。随着移动端应用的兴起和各种网络游戏的盛行，百万级长连接日趋普遍，此时，必然需要一种更高效的I/O处理模型。

以前传统socket编程时，accept方法会一直阻塞，直到有客户端请求的到来，并返回socket进行相应的处理。整个过程是就像烧水时直到水壶烧开了(响应回去了)才能去处理下一个请求.当然我们也可以用线程池的模式.

上面为什么是每连接每线程呢？为啥不可以是单线程多连接呢？  
语法上实现单线程多连接是没有问题的，但是你想想，所有IO操作都是阻塞的，所以在一个线程里只能处理一个socket，就算accept了多个也没用，前一个socket被阻塞了，后面的是无法被执行到的。

所以上面每连接每线程的模型即使有很多缺点，依然是bio下的最佳方式，这是bio自身阻塞缺点决定的。

NIO则为我们提供了更好的解决方案，Selector选择器能够检测多个注册的通道上是否有事件发生，如果有事件发生，便获取事件然后针对每个事件进行相应的响应处理。这样一来，只是用一个单线程就可以管理多个通道，也就是管理多个连接。这样使得只有在连接真正有读写事件发生时，才会调用函数来进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程，并且避免了多线程之间的上下文切换导致的开销。并且是按顺序处理，基于通道（Channel）和缓冲区（Buffer）来传输和保存数据。

JavaNIO和BIO比较  
1.IO只能实现阻塞式的网络通信。NIO能够实现非阻塞的网络通信.(废话)  
2.标准IO基于字节/字符流进行操作；而NIO是基于通道(Channel)进行操作的。  
3.流的读写通常是单向的，要么输入，要么输出，不能既是输入流又是输出流。通道是双向的，既可以写数据到通道，又可以从通道中读取数据；

虽然现在我们不会直接编写NIO来完成我们的网络层通讯，而是使用成熟的基于NIO的网络框架来实现我们的网络层。如，netty、mina。但对NIO网络编程过程的了解，非常有助于我们更深入的理解netty、mina等网络框架（https://blog.csdn.net/h2604396739/article/details/81123143），以至于能更好的使用它们。有人问了,不学这个对我敲代码有何影响,可以说,毛影响都没.

知道什么是NIO后,我们再来看看java NIO的三个重要组成部分:  
Channel（通道），Buffer（缓冲区），Selector（选择器）。

Channel   
通道，顾名思义，就是通向什么的道路，为某个提供了渠道。  
1.传统IO中，Stream是单向的，比如InputStream只能进行读取操作，OutputStream只能进行写操作。  
而Channel是双向的，既可用来进行读操作，又可用来进行写操作。  
2.具体的常见实现通道有FileChannel,SocketChanel,ServerSocketChannel,DatagramChannel等  
跟具体的实现流FileInputStream,FileOutputStream,FileReader,FileWriter,节点流包装流缓冲流等等功能类似

Buffer  
缓冲区，是NIO中非常重要的一个东西，实际上就是一个容器，是一个连续数组。在NIO中所有数据的读和写都离不开Buffer。在NIO中，读取的数据只能放在Buffer中。同样地，写入数据也是先写入到Buffer中。  
简单的讲就是,要想使用Channel(通道)传递数据,必须先把数据丢进Buffer(缓冲区,容器)里.

在NIO中，Buffer是一个顶层父类，它是一个抽象类，常用的Buffer的子类有：  
ByteBuffer,IntBuffer,CharBuffer,LongBuffer,DoubleBuffer,FloatBuffer,ShortBuffer

Selector    
选择器, 可以说它是NIO中最关键的一个部分，Selector的作用就是用来轮询每个注册的Channel，一旦发现Channel有注册的事件发生，便获取事件然后进行处理。  
Nio通过多路复用的方式让一个线程去处理多个Socket。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gyNjA0Mzk2NzM5_size_16_color_FFFFFF_t_70][]

这样一来，只需要使用少量的线程就可以搞定多个socket了，线程只需要通过Selector去查一下它所管理的socket集合，哪个Socket的数据准备好了，就去处理哪个Socket，一点儿都不浪费。

与Selector有关的一个关键类是SelectionKey，一个SelectionKey表示一个到达的事件，这2个类构成了服务端处理业务的关键逻辑。再看下nio的使用  
nio文件读取的使用  
java.nio.\*  
速度的提高来自于所使用的结构更接近于操作系统执行IO的方式：通道（channel）和缓冲器（ByteBuffer）  
FileInputStream FileOutputStream RandomAccessFile用以产生FileCHannel  
FileChannel fc= new RandomAccessFile(“data.txt”,”rw”).getChannel();  
fc.position(fc.size());//移动到尾部，在尾部追加内容。  
fc.write(ByteBuffer.wrap(“sone test”.getBytes()))  
fc.close()。  
或 文件拷贝  
FileChannel in= new RandomAccessFile(“data.txt”,”rw”).getChannel();  
FileChannel out= new RandomAccessFile(“dataNew.txt”,”rw”).getChannel();  
ByteBuffer buffer = ByteBuffer.allocate(1024);  
while(in.read(buffer) != -1)\{  
    buffer.flip();//为写做准备  
    out.write(buffer);  
    buffer.clear();  
\}

nio在网络编程中的使用  
对NIO的使用:  
NIO的读写函数可以立刻返回，这就给了我们不开线程利用CPU的最好机会：如果一个连接不能读写（socket.read()返回0或者socket.write()返回0），我们可以把这件事记下来，记录的方式通常是在Selector上注册标记位，然后切换到其它就绪的连接（channel）继续进行读写。

interface ChannelHandler{
          void channelReadable(Channel channel);
          void channelWritable(Channel channel);
       }
       class Channel{
         Socket socket;
         Event event;//读，写或者连接
       }
    
       //IO线程主循环:
       class IoThread extends Thread{
       public void run(){
       Channel channel;
       while(channel=Selector.select()){//选择就绪的事件和对应的连接
          if(channel.event==accept){
             registerNewChannelHandler(channel);//如果是新连接，则注册一个新的读写处理器
          }
          if(channel.event==write){
             getChannelHandler(channel).channelWritable(channel);//如果可以写，则执行写事件
          }
          if(channel.event==read){
              getChannelHandler(channel).channelReadable(channel);//如果可以读，则执行读事件
          }
        }
       }
       Map<Channel，ChannelHandler> handlerMap;//所有channel的对应事件处理器
      }

这个程序很简短，也是最简单的Reactor模式：注册所有感兴趣的事件处理器，单线程轮询选择就绪事件，执行事件处理器。

nio下的reactor模式见https://blog.csdn.net/h2604396739/article/details/81123143

nio到aio  
NIO2.0引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。异步通道提供两种方式获取操作结果。  
通过Java.util.concurrent.Future类来表示异步操作的结果；  
在执行异步操作的时候传入一个Java.nio.channels.  
CompletionHandler接口的实现类作为操作完成的回调。  
NIO2.0的异步套接字通道是真正的异步非阻塞IO，它对应UNIX网络编程中的事件驱动IO(AIO)，它不需要通过多路复用器(Selector)对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO的编程模型。

我们可以得出结论：异步Socket Channel是被动执行对象，我们不需要像NIO编程那样创建一个独立的IO线程来处理读写操作。对于AsynchronousServerSocketChannel和AsynchronousSocketChannel，它们都由JDK底层的线程池负责回调并驱动读写操作。正因为如此，基于NIO2.0新的异步非阻塞Channel进行编程比NIO编程更为简单。

应用到aio的通信框架:talent-aio,这里不介绍。

面试题 :channel读取过程中，怎么将不同片段写入到不同Buffer中？

NIO-scatter机制来写入不同buffer  
Code:  
ByteBuffer header = ByteBuffer.allocate(128);  
ByteBuffer body = ByteBuffer.allocate(1024);  
ByteBuffer\[\] bufferArray = \{header, body\};  
channel.write(bufferArray);  
注意:该方法适用于请求头长度固定。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gyNjA0Mzk2NzM5_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/24d1d89fd4ee4e659542428e8ab5b67a.png