Java SE基础巩固(六):Java IO

Java SE基础巩固(六):Java IO

到现在为止,Java IO可分为三类:BIO、NIO、AIO。最早出现的是BIO,然后是NIO,最近的是AIO,BIO即Blocking IO,NIO有的文章说是New NIO,也有的文章说是No Blocking IO,我查了一些资料,官网说的应该是No Blocking IO,提供了Selector,Channle,SelectionKey抽象,AIO即Asynchronous IO(异步IO),提供了Fauture等异步操作。

1 BIO

[](https://imgchr.com/i/i81QZn)

[i81QZn.png

](https://imgchr.com/i/i81QZn)

上图是BIO的架构体系图。可以看到BIO主要分为两类IO,即字符流IO和字节流IO,字符流即把输入输出数据当做字符来看待,Writer和Reader是其继承体系的最高层,字节流即把输入输出当做字节来看待,InputStream和OutputStream是其继承体系的最高层。下面以文件操作为例,其他的实现类也非常类似。

《2020最新Java基础精讲视频教程和学习路线!》

顺便说一下,整个BIO体系大量使用了装饰者模式,例如BufferedInputStream包装了InputStream,使其拥有了缓冲的能力。

1.1 字节流

public class Main {

    public static void main(String[] args) throws IOException {
        //写入文件
        FileOutputStream out = new FileOutputStream("E:Java_projecteffective-javasrctopyeononiobiotest.txt");
        out.write("hello,world".getBytes("UTF-8"));
        out.flush();
        out.close();

        //读取文件
        FileInputStream in = new FileInputStream("E:Java_projecteffective-javasrctopyeononiobiotest.txt");
        byte[] buffer = new byte[in.available()];
        in.read(buffer);
        System.out.println(new String(buffer, "UTF-8"));
        in.close();
    }
}

复制代码

向FileOutputStream构造函数中传入文件名来创建FileOutputStream对象,即打开了一个字节流,之后使用write方法向字节流中写入数据,完成之后调用flush刷新缓冲区,最后记得要关闭字节流。读取文件也是类似的,先打开一个字节流,然后从字节流中读取数据并存入内存中(buffer数组),然后再关闭字节流。

因为InputStream和OutputStream都继承了AutoCloseable接口,所以如果使用的是try-resource的语法来进行字节流的IO操作,可不需要手动显式调用close方法了,这也是非常推荐的做法,在示例中我没有这样做只是为了方便。

1.2 字符流

字节流主要使用的是InputStream和OutputStream,而字符流主要使用的就是与之对应的Reader和Writer。下面来看一个示例,该示例的功能和上述示例的一样,只不过实现手段不同:

public class Main {

    public static void main(String[] args) throws IOException {
        Writer writer = new FileWriter("E:Java_projecteffective-javasrctopyeononiobiotest.txt");
        writer.write("hello,worldn");
        writer.write("hello,yeononn");
        writer.flush();
        writer.close();

        BufferedReader reader = new BufferedReader(new FileReader("E:Java_projecteffective-javasrctopyeononiobiotest.txt"));

        String line = "";
        int lineCount = 0;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
            lineCount++;
        }
        reader.close();
        System.out.println(lineCount);
    }
}
复制代码

Writer非常简单,无法就是打开字符流,然后向字符流中写入字符,然后关闭。关键是Reader,示例代码中使用了BufferedReader来包装FileReader,使得原本没有缓冲功能的FileReader有了缓冲功能,这就是上面提到过的装饰者模式,BufferedReader还提供了方便使用的API,例如readLine(),这个方法每次调用会读取文件中的一行。

以上就是BIO的简单使用,源码的话因为涉及太多的底层,所以如果对底层不是很了解的话会很难理解源码。

2 NIO

BIO是同步阻塞的IO,而NIO是同步非阻塞的IO。NIO中有几个比较重要的组件:Selector,SelectionKey,Channel,ByteBuffer,其中Selector就是所谓的选择器,SelectionKey可以简单理解为选择键,这个键将Selector和Channle进行一个绑定(或者所Channle注册到Selector上),当有数据到达Channel的时候,Selector会从阻塞状态中恢复过来,并对该Channle进行操作,并且,我们不能直接对Channle进行读写操作,只能对ByteBuffer操作。如下图所示:

[](https://imgchr.com/i/i8YB80)

[i8YB80.png

](https://imgchr.com/i/i8YB80)

下面是一个Socket网络编程的例子:

//服务端
public class SocketServer {

    private Selector selector;
    private final static int port = 9000;
    private final static int BUF = 10240;

    private void init() throws IOException {
        //获取一个Selector
        selector = Selector.open();
        //获取一个服务端socket Channel
        ServerSocketChannel channel = ServerSocketChannel.open();
        //设置为非阻塞模式
        channel.configureBlocking(false);
        //绑定端口
        channel.socket().bind(new InetSocketAddress(port));
        //把channle注册到Selector上,并表示对ACCEPT事件感兴趣
        SelectionKey selectionKey = channel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            //该方法会阻塞,直到和其绑定的任何一个channel有数据过来
            selector.select();
            //获取该Selector绑定的SelectionKey
            Set selectionKeys = selector.selectedKeys();
            Iterator iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                //记得删除,否则就无限循环了
                iterator.remove();
                //如果该事件是一个ACCEPT,那么就执行doAccept方法,其他的也一样
                if (key.isAcceptable()) {
                    doAccept(key);
                } else if (key.isReadable()) {
                    doRead(key);
                } else if (key.isWritable()) {
                    doWrite(key);
                } else if (key.isConnectable()) {
                    System.out.println("连接成功!");
                }
            }
        }
    }

    //写方法,注意不能直接对channle进行读写操作,只能对ByteBuffer进行操作
    private void doWrite(SelectionKey key) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(BUF);
        buffer.flip();
        SocketChannel socketChannel = (SocketChannel) key.channel();
        while (buffer.hasRemaining()) {
            socketChannel.write(buffer);
        }
        buffer.compact();
    }

    //读取消息
    private void doRead(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(BUF);
        long reads = socketChannel.read(buffer);
        while (reads > 0) {
            buffer.flip();
            byte[] data = buffer.array();
            System.out.println("读取到消息: " + new String(data, "UTF-8"));
            buffer.clear();
            reads = socketChannel.read(buffer);
        }
        if (reads == -1) {
            socketChannel.close();
        }
    }

    //当有连接过来的时候,获取连接过来的channle,然后注册到Selector上,并设置成对读消息感兴趣,当客户端有消息过来的时候,Selector就可以让其执行doRead方法,然后读取消息并打印。
    private void doAccept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        System.out.println("服务端监听中...");
        SocketChannel socketChannel = serverChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(key.selector(), SelectionKey.OP_READ);
    }
    
    public static void main(String[] args) throws IOException {
        SocketServer server = new SocketServer();
        server.init();
    }
}

//客户端,写得比较简单
public class SocketClient {

    private final static int port = 9000;
    private final static int BUF = 10240;


    private void init() throws IOException {
        //获取channel
        SocketChannel channel = SocketChannel.open();
        //连接到远程服务器
        channel.connect(new InetSocketAddress(port));
        //设置非阻塞模式
        channel.configureBlocking(false);
        //往ByteBuffer里写消息
        ByteBuffer buffer = ByteBuffer.allocate(BUF);
        buffer.put("Hello,Server".getBytes("UTF-8"));
        buffer.flip();
        //将ByteBuffer内容写入Channle,即发送消息
        channel.write(buffer);
        channel.close();
    }


    public static void main(String[] args) throws IOException {
        SocketClient client = new SocketClient();
            client.init();
    }
}

复制代码

尝试启动一个服务端,多个客户端,结果大致如下所示:

服务端监听中...
读取到消息: Hello,Server                       
服务端监听中...
读取到消息: Hello,Server  
复制代码

注释写得挺清楚了,我这里只是简单使用了NIO,但实际上NIO远远不止这些东西,光一个ByteBuffer就能说一天,如果有机会,我会在后面Netty相关的文章中详细说一下这几个组件。在此就不再多说了。

吐槽一些,纯NIO写的服务端和客户端实在是太麻烦了,一不小心就会写错,还是使用Netty类似的框架好一些啊。

3 AIO

在JDK7中新增了一些IO相关的API,这些API称作AIO。因为其提供了一些异步操作IO的功能,但本质是其实还是NIO,所以可以简单的理解为是NIO的扩充。AIO中最重要的就是Future了,Future表示将来的意思,即这个操作可能会持续很长时间,但我不会等,而是到将来操作完成的时候,再过来通知我,这就是异步的意思。下面是两个使用AIO的例子:

 public static void main(String[] args) throws ExecutionException, InterruptedException, IOException {
        Path path = Paths.get("E:Java_projecteffective-javasrctopyeononioaiotest.txt");
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        Future future = channel.read(buffer,0);
        Integer readNum = future.get(); //阻塞,如果不调用该方法,main方法会继续执行
        buffer.flip();
        System.out.println(new String(buffer.array(), "UTF-8"));
        System.out.println(readNum);
    }
复制代码

第一个例子使用AsynchronousFileChannel来异步的读取文件内容,在代码中,我使用了future.get()方法,该方法会阻塞当前线程,在例子中即主线程,当工作线程,即读取文件的线程执行完毕后才会从阻塞状态中恢复过来,并将结果返回。之后就可以从ByteBuffer中读取数据了。这是使用将来时的例子,下面来看看使用回调的例子:

public class Main {

    public static void main(String[] args) throws ExecutionException, InterruptedException, IOException {
        Path path = Paths.get("E:Java_projecteffective-javasrctopyeononioaiotest.txt");
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer, 0, buffer, new CompletionHandler() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                System.out.println("完成读取");
                try {
                    System.out.println(new String(attachment.array(), "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("读取失败");
            }
        });
        System.out.println("继续执行主线程");
        //调用完成之后不需要等待任务完成,会直接继续执行主线程
        while (true) {
            Thread.sleep(1000);
        }
    }
}

复制代码

输出的结果大致如下所示,但不一定,这取决于线程调度:

继续执行主线程
完成读取

hello,world
hello,yeonon
复制代码

当任务完成,即读取文件完毕的时候,会调用completed方法,失败会调用failed方法,这就是回调。详细接触过回调的朋友应该不难理解。

4 BIO、NIO、AIO的区别

  1. BIO是同步阻塞的IO,NIO是同步非阻塞IO,AIO异步非阻塞IO,这是最基本的区别。阻塞模式会导致其他线程被IO线程阻塞,必须等待IO线程执行完毕才能继续执行逻辑,非阻塞和异步并不等同,非阻塞模式下,一般会采用事件轮询的方式来执行IO,即IO多路复用,虽然仍然是同步的,但执行效率比传统的BIO要高很多,AIO则是异步IO,如果把IO工作当做一个任务的话,在当前线程中提交一个任务之后,不会有阻塞,会继续执行当前线程的后续逻辑,在任务完成之后,当前线程会收到通知,然后再决定如何处理,这种方式的IO,CPU效率是最高的,CPU几乎没有发生过停顿,而时一直至于忙状态,所以效率非常高,但编程难度会比较大。
  2. BIO面向的是流,无论是字符流还是字节流,通俗的讲,BIO在读写数据的时候会按照一个接一个的方式读写,而NIO和AIO(因为AIO实际上是NIO的扩充,所以从这个方面来看,可以把他们放在一块)读写数据的时候是按照一块一块的读取的,读取到的数据会缓存在内存中,然后在内存中对数据进行处理,这种方式的好处是减少了硬盘或者网络的读写次数,从而降低了由于硬盘或网络速度慢带来的效率影响。
  3. BIO的API虽然比较底层,但如果熟悉之后编写起来会比较容易,NIO或者AIO的API抽象层次高,一般来说应该更容易使用才是,但实际上却很难“正确”的编写,而且DEBUG的难度也较大,这也是为什么Netty等NIO框架受欢迎的原因之一。

以上就是我理解的BIO、NIO和AIO区别。

5 小结

本文简单粗略的讲了一下BIO、NIO、AIO的使用,并未涉及源码,也没有涉及太多的原理,如果读者希望了解更多关于三者的内容,建议参看一些书籍,例如老外写的《Java NIO》,该书全面系统的讲解了NIO的各种组件和细节,非常推荐。

你可能感兴趣的