IT技术之家

首页 > Android

Android

Java I/O相关知识(BIO、NIO、AIO)_小小本科生debug

发布时间:2022-10-24 18:00:15 Android 0次 标签:java I/O 网络编程 Netty
Java I/O一:Unix I/O模型二:Java I/O模型一:Unix I/O模型Linux的内核将所有外部设备都看做一个文件来操作,对一个文件的读写操作会调用内核提供的系统命令,返回一个file descriptor (fd,文件描述符)。而对一个 socket 的读写也会有相应的描述符,称之为 socket fd (socket描述符)。描述符就是一个数字,它指向内核中的一个结构体(文件路径,数据区等一些属性)。根据UNIX网络编程对I/O模型的分类,UNIX提供了5种I/O模型:阻塞I/O...

Java I/O

一:Unix I/O模型二:什么是 Sockets1、阻塞I/O模型2、非阻塞式I/O模型3、I/O复用模型4、信号驱动I/O模型5、异步I/O模型6、五种I/O模型的比较7、I/O多路复用技术 三:Java I/O模型1、BIO2、BIO 举例3、NIOBuffer(缓冲区)Channel(通道)Selector(多路复用器) 4、AIO(NIO2) 四:Netty框架

一:Unix I/O模型

Linux的内核将所有外部设备都看做一个文件来操作,对一个文件的读写操作会调用内核提供的系统命令,返回一个file descriptor (fd,文件描述符)。而对一个 socket 的读写也会有相应的描述符,称之为 socket fd (socket描述符)。描述符就是一个数字,它指向内核中的一个结构体(文件路径,数据区等一些属性)。

根据UNIX网络编程对I/O模型的分类,UNIX提供了5种 I/O 模型:阻塞I/O模型非阻塞式I/O模型I/O复用模型信号驱动I/O模型异步I/O模型

二:什么是 Sockets

应用层通过传输层进行数据通信时,TCP和UDP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要 通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接,许多计算机操作系统为应用程序与TCP/IP协议交互提供了称为套接字 (Socket)的接口,区分不同应用程序进程间的网络通信和连接。生成套接字,主要有3个参数:通信的目的IP地址、使用的传输 层协议(TCP或UDP)和使用的端口号。Socket原意是"插座"。通过将这3个参数结合起来,与一个 “插座” Socket绑定,应用层就可以和传输 层通过套接字接口,区分来自不同应用程序进程或网络连接的通信,实现数据传输的并发服务。

1、阻塞I/O模型

最常用的 I/O 模型就是阻塞 I/O 模型,缺省情况下,所有文件操作都是阻塞的。我们以套接字接口为例讲解此模型:在进程空间中调用 recvfrom ,其系统调用直到数据包到达且被复制到应用进程的缓冲区中或者发生错误时才返回,在此期间会一直等待,进程再从调用 recvfrom 开始到它返回的整段时间内都是被阻塞的,因此被称为阻塞 I/O 模型。

2、非阻塞式I/O模型

性能较阻塞 I/O 来说也没啥提升。

recvfrom 从应用层到达内核的时候,如果该缓冲区没有数据的话,就直接返回一个 EWOULDBLOCK 错误,一般都对非阻塞 I/O 模型进行轮询检查这个状态,看内核是不是有数据到来。

3、I/O复用模型

Linux提供 select/poll,进程通过将一个或多个 fd 传递给 select 或 poll 系统调用,阻塞在select操作上,这样 select/poll 可以帮我们侦测多个 fd 是否处于就绪状态这个就是 I/O 复用的优势所在,可以同时处理多个文件)。select/poll 是顺序扫描 fd 是否就绪,而且支持的 fd 数量有限,因此它的使用受到了一些制约。Linux还提供了一个 epoll 系统调用,epoll 使用基于事件驱动方式代替顺序扫描,因此性能更高。当有 fd 就绪时,立即回调函数 callback 。I/O 复用模型的优势是,我们可以等待多个描述符就绪

4、信号驱动I/O模型

首先开启套接口信号驱动 I/O 功能,并通过系统调用sigaction执行一个信号处理函数(此系统调用立即返回,进程继续工作,它是非阻塞的)。当数据准备就绪时,就为该进程生成一个 SIGIO 信号,通过信号回调通知应用程序调用 recvfrom 来读取数据,并通知主循环函数处理数据。

这种方式并不见得要比 I/O 多路复用性能要好,因为虽然 I/O 复用阻塞,但是它可以扫描多个文件描述符,如果再用 epoll 来优化优化,那么性能会很好的。信号驱动 I/O 虽然第一阶段是不阻塞的,但是它一次只能够处理一个文件描述符(处理能力有限)。

I/O 复用是用一个线程就能处理多个远程调用的访问,处理能力是比较强的。而信号驱动 I/O 要处理多个用户访问的话是要创建多个线程的。

5、异步I/O模型

告知内核启动某个操作,并让内核在整个操作完成后(包括将数据从内核复制到用户自己的缓冲区)通知我们。这种模型与信号驱动模型的主要区别是:信号驱动I/O由内核通知我们何时开始一个I/O操作;异步I/O模型由内核通知我们I/O操作何时已经完成。

两个阶段都不阻塞。他是直接告诉内核把数据一步到位的准备好放在用户缓冲区后再通知我。

但是并不是所有的操作系统都支持这种 I/O 模式,这种模式的使用是受限的。

6、五种I/O模型的比较

7、I/O多路复用技术

I/O多路复用技术通过把多个I/O的阻塞复用到同一个select的阻塞上,从而使得系统在单线程的情况下可以同时处理多个客户端请求。与传统的多线程/多进程模型比,I/O多路复用的最大优势是系统开销小,系统不需要创建新的额外的进程或者线程,也不需要维护这些进程和线程的运行,降低了系统的维
护工作量,节省了系统资源。目前支持I/O多路复用的系统调用有select、pselect、poll、epoll,在Linux网络编程过程中,很长一段时间都使用select做轮询和网络事件通知,然而select的一些固有缺陷导致了它的应用受到了很大的限制,最终Linux不得不在新的内核版本中寻找select的替代方案,最终选择了epoll。

为了克服select的缺点,epoll做了很多重大改进,主要有如下两点:

    支持一个进程打开的socket描述符不受限制
    select最大的缺陷就是单个进程所打开的FD是有一定限制的,它由FD_SETSIZE设置,默认值是1024。对于那些需要支持上万个TCP连接的大型服务器来说显然太少了。epoll并没有这个限制,它所支持的 FD 上限是操作系统的最大文件句柄数,这个数字远远大于1024。例如,在1GB内存的机器上大约是10万个句柄左右。I/O效率不会随着FD数目的增加而线性下降传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合,由于网络延时或者链路空闲,任一时刻只有少部分的socket是“活跃”的,但是select/poll每次调用都会线性扫描全部的集合,导致效率呈现线性下降。epoll不存在这个问题,它只会对“活跃”的socket进行操作。这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的,那么,只有“活跃”的socket才会主动的去调用callback函数,其他空闲状态socket则不会。

三:Java I/O模型

1、BIO

在1.4之前,Java只提供了一种IO模型,即阻塞式IO模型(BIO)。就是IO流

所以在JDK1.4之前,如果有网络编程方面的业务,一般都不会选择Java,因为它的IO是阻塞的,而更偏向于C++。


红色的是低级流,蓝色的是比较高级的流。

2、BIO 举例

public class BIOServer {
    public static void main(String[] args) throws Exception {

        //线程池机制

        //思路
        //1. 创建一个线程池
        //2. 如果有客户端连接,就创建一个线程,与之通讯(单独写一个方法)
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();

        //创建ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动了");

        while (true) {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            //监听,等待客户端连接
            System.out.println("等待连接....");
            final Socket socket = serverSocket.accept();
            System.out.println("连接到一个客户端");

            //就创建一个线程,与之通讯(单独写一个方法)
            newCachedThreadPool.execute(new Runnable() {
                public void run() { //我们重写
                    //可以和客户端通讯
                    handler(socket);
                }
            });
        }
    }

    //编写一个handler方法,和客户端通讯
    public static void handler(Socket socket) {
        try {
            System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket 获取输入流
            InputStream inputStream = socket.getInputStream();

            //循环的读取客户端发送的数据
            while (true) {
                System.out.println("线程信息 id =" + Thread.currentThread().getId() + " 名字=" + Thread.currentThread().getName());
                System.out.println("read....");

               int read =  inputStream.read(bytes);
               if(read != -1) {
                   System.out.println(new String(bytes, 0, read
                   )); //输出客户端发送的数据
               } else {
                   break;
               }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            System.out.println("关闭和client的连接");
            try {
                socket.close();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

3、NIO

新的输入/输出(NIO)库是在JDK 1.4中引入的。NIO弥补了原来同步阻塞I/O的不足,它在标准Java代码中提供了高速的、面向块的I/O。通过定义包含数据的类,以及通过以块的形式处理这些数据。NIO包含三个核心的组件:Buffer(缓冲区)Channel(通道)Selector(多路复用器)

Buffer(缓冲区)

Buffer是一个对象,它包含一些要写入或者要读出的数据。在NIO类库中加入Buffer对象,体现了新库与原I/O的一个重要区别。在面向流的I/O中,可以将数据直接写入或者将数据直接读到Stream对象中。在NIO库中,所有数据都是用缓冲区处理的。在读取数据时,它是直接读到缓冲区中的。在写入数据时,写入到缓冲区中。任何时候访问NIO中的数据,都是通过缓冲区进行操作。

? Buffer是抽象类,它有如下子类:
ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer;

? 只能通过静态方法实例化Buffer:
public static ByteBuffer allocate(int capacity); // 分配堆内存

public static ByteBuffer allocateDirect(int capacity); // 分配直接内存

? Buffer中的四个成员变量:

    容量(capacity):Buffer可以存储的最大数据量,该值不可改变;界限(limit):Buffer中可以读/写数据的边界,limit之后的数据不能访问;位置(position):下一个可以被读写的数据的位置(索引);标记(mark):Buffer允许将位置直接定位到该标记处,这是一个可选属性;这就是相对于传统 I/O 流的优势所在,传统 I/O 是不能够逆向读的,但是使用Buffer是可以进行跳跃的。
    并且,上述变量满足如下的关系:0 <= mark <= position <= limit <= capacity 。

    ? Buffer中数据变化的过程:

Channel(通道)

Channel是一个通道,可以通过它读取和写入数据,它就像自来水管一样,网络数据通过Channel读取和写入。通道与流的不同之处在于通道是双向的流只是在一个方向上移动而且通道可以用于读、写或者同时用于读写。因为Channel是全双工的,所以它可以比流更好地映射底层操作系统的API。特别是在UNIX网络编程模型中,底层操作系统的通道都是全双工的,同时支持读写操作。

? Channel的实现类:
1、FileChannel:文件访问通道;
2、SocketChannel、ServerSocketChannel:TCP通信通道;
3、DatagramChannel:UDP通信通道;
4、Pipe.SourceChannel、Pipe.SinkChannel:线程通信通道。

? Channel的实例化:
1、各个Channel类提供的open()方法;
2、字节流提供了getChannel()方法,可以直接返回FileChannel。

? Channel的方法:
1、map()方法用于将Channel对应的数据映射成ByteBuffer;
2、read()方法有一系列重载的形式,用于从Buffer中读取数据;
3、write()方法有一系列重载的形式,用于向Buffer中写入数据。

Selector(多路复用器)

Selector会不断地轮询注册在其上的Channel,如果某个Channel上面有新的TCP连接接入、读和写事件,这个Channel就处于就绪状态,会被Selector轮询出来,然后通过SelectionKey可以获取就绪Channel的集合,进行后续的I/O操作。一个多路复用器Selector可以同时轮询多个Channel由于JDK使用了 epoll() 代替传统的select实现,所以它并没有最大连接句柄 1024/2048 的限制。这也就意味着只需要一个线程负责Selector的轮询,就可以接入成千上万的客户端,这确实是个非常巨大的进步。

Selector是抽象类,可以通过调用此类的 open() 静态方法来创建Selector实例。Selector可以同时监控多个SelectableChannel的 IO 状况,是非阻塞IO的核心。一个Selector实例有三个SelectionKey集合:

    所有的SelectionKey集合:代表了注册在该Selector上的Channel,这个集合可以通过keys()方法返回。被选择的SelectionKey集合:代表了所有可通过 select() 方法获取的、需要进行 IO 处理的Channel,这个集合可以通过 selectedKeys() 返回。被取消的SelectionKey集合:代表了所有被取消注册关系的Channel,在下一次执行 select() 方法时,这些Channel对应的SelectionKey会被彻底删除,程序通常无须直接访问该集合。

Selector还提供了一系列和 select() 相关的方法:

    int select():监控所有注册的Channel,当它们中间有需要处理的IO操作时,该方法返回,并将对应的SelectionKey加入被选择的SelectionKey集合中,该方法返回这些Channel的数量。int select(long timeout):可以设置超时时长的select()操作。int selectNow():执行一个立即返回的select()操作,相对于无参数的select()方法而言,该方法不会阻塞线程。Selector wakeup():使一个还未返回的select()方法立刻返回。


1)当客户端连接时,会通过ServerSocketChannel 得到SocketChannel
2) Selector进行监听 select 方法,返回有事件发生的通道的个数
3) 将socketChannel 注册到 Selector 上, register(Selector sel,int ops),一个selector上可以注册多个SocketChannel
4)注册后返回一个 SelectionKey(selectedKeys方法),会和该Selector关联
5)进一步得到各个 SelectionKey (有事件发生)
6)再通过 SelectionKey 反向获取 SocketChannel,方法channel()
SocketChannel channel = (SocketChannel)key.channel();
7)可以通过得到的 channel ,完成业务处理

4、AIO(NIO2)

Java 7的 NIO2 提供了异步Channel支持,这种异步Channel可以提供更高效的IO,这种基于异步Channel的IO机制也被称为异步IO(AsynchronousIO)
NIO2为AIO提供了两个接口和三个实现类,其AsynchronousSocketChannel
和AsynchronousServerSocketChannel是支持TCP通信的异步Channel。

四:Netty框架

在进行磁盘IO操作时,建议使用NIO。在进行网络IO操作时,则建议使用Netty框架,原因如下

    NIO的类库和API繁杂,使用麻烦,你需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等类;需要具备其他额外的技能做铺垫,例如熟悉Java多线程编程。这是因为NIO编程设计到Reactor模式,你必须对多线程和网络编程非常熟悉,才能编写出高质量的NIO程序;可靠性能力补齐,工作量和难度都非常大。例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常码流的处理等问题,NIO编程的特点是功能开发相对容易,但是可靠性能力补齐的工作量和难度都非常大;JDK NIO的BUG,例如臭名昭著的epoll bug,它会导致Selector空轮询,最终导致CPU 100%。官方声称在JDK 1.6版本的update18修复了该问题,但是直到JDK 1.7版本该问题仍旧存在,只不过该BUG发生的概率降低了一些而已,它并没有得到根本性的解决。