I/O模型与Java
I/O模型与Java
那只是一股逆流 发表于1年前
I/O模型与Java
  • 发表于 1年前
  • 阅读 25
  • 收藏 0
  • 点赞 0
  • 评论 0

华为云·免费上云实践>>>   

摘要: 刚开始接触IO知识的时候,总是分不清同步与异步、阻塞与非阻塞。随着学习的深入,渐渐来到了痛点区域 - 不弄懂全身感觉不舒服,非弄懂不可。 下面我就从我的理解来阐述一下IO相关知识。

原文已同步至http://liumian.win/2016/11/23/io-model-and-java/


学习I/O模型之前,首先要明白几个概念:

  • 同步、异步
  • 阻塞、非阻塞

这几个概念往往是成对出现的,我们常常能够看到同步阻塞,异步非阻塞等描述,正因为如此我们往往在脑海里面是一个模糊的概念 - “哦,他们是这个样子啊,都差不多嘛”。

我刚开始接触IO知识的时候,也存在上述的问题,分不清他们的区别。随着学习的深入,渐渐来到了痛点区域 - 不弄懂全身感觉不舒服,非弄懂不可。

同步与异步 描述的是用户线程与内核的交互方式:

  • 同步是指用户线程发起 I/O 请求后需要等待或者轮询内核 I/O 操作完成后才能继续执行;
  • 异步是指用户线程发起 I/O 请求后仍继续执行,当内核 I/O 操作完成后会通知用户线程,或者调用用户线程注册的回调函数。

阻塞和非阻塞 描述的是用户线程调用内核 I/O 操作的方式:

  • 阻塞是指 I/O 操作需要彻底完成后才返回到用户空间;
  • 非阻塞是指 I/O 操作被调用后立即返回给用户一个状态值,无需等到 I/O 操作彻底完成。

下面来看一种五种常见IO模型的对比,相信你看了这张图片以后很快就会明白同步、异步、阻塞和非阻塞的区别。

五种IO模型

首先我们得明白一次IO操作是需要两个阶段的:准备数据(内核空间) -> 数据从内核空间拷贝到用户空间。为什么要这么做呢?因为操作系统在内存中划分了两个区域:一个是内核空间,一个是用户空间。内核空间是留给操作系统进行系统服务的,而用户空间就是我们的程序运行的内存空间。而操作系统为了系统的安全是不允许我们的程序直接操作内存空间的,所以我们必须等待操作系统把磁盘上面的内容读入到内核空间,然后拷贝到用户空间才能操作。从图片的右侧也可以清晰的发现这两个阶段。

这觉得这篇博客总结得非常好,他说: >一个 I/O 操作其实分成了两个步骤:发起 I/O 请求和实际的 I/O 操作。 阻塞 I/O 和非阻塞 I/O 的区别在于第一步,发起 I/O 请求是否会被阻塞,如果阻塞直到完成那么就是传统的阻塞 I/O ,如果不阻塞,那么就是非阻塞 I/O 。 同步 I/O 和异步 I/O 的区别就在于第二个步骤是否阻塞,如果实际的 I/O 读写阻塞请求进程,那么就是同步 I/O 。

好了,经过上面的解释是不是对IO相关知识理解又深刻一些了呢?又或者是模糊了许多呢?都没关系,下面开始进行详细的IO模型分析。

  1. 阻塞IO模型(BIO) 如果IO请求无法立即完成,那么当前线程进入阻塞状态。 不管是第一阶段还是第二阶段,全部阻塞。

  2. 非阻塞IO 模型(Non-blinking IO) 第一阶段(准备数据)不会阻塞,第二阶段(拷贝数据到用户空间)会阻塞。 因为第一阶段不会阻塞,所以我们只有不断的轮询数据在内核空间是否准备完成,这个过程会造成CPU空转,浪费了宝贵的CPU时间。所以不推荐直接使用这种IO模型进行项目开发。

  3. I/O复用模型 从图中我们可以看到,两个阶段都阻塞了。那么I/O复用模型和阻塞模型有什么区别呢? 进(线)程将一个或者多个感兴趣的事件(可读、可写等)注册在select方法上面,当事件处于就绪状态时意味着数据在用户空间已经准备好(就绪之前为阻塞状态),那么该方法就会返回执行后面的代码,然后又会阻塞在recvfrom(将数据拷贝到用户空间)这个过程直至完成。 如果您之前用过Java中的Selector,可能很容易理解这块知识。

  4. 信号驱动I/O模型 这块我不是很熟,《Netty权威指南》是这样解释的: 首先开启套接口信号驱动I/O功能,并通过系统调用sigaction执行一个信号处理函数(此系统调用立即返回,进程继续工作,他是非阻塞的)。当数据准备就绪时,就为该进程生成一个SIGIO信号,通过信号回调通知应用程序调用recvfrom来读取数据,并通知主循环函数处理数据。

  5. 异步I/O模型(AIO) 两个阶段均不阻塞线程。工作原理为:通知内核启动某个IO操作,内核将数据复制到用户空间(我们指定的空间)后通知我们。这个过程用户线程不会阻塞。

说了这么多大家是不是想问,你不是说Java中的I/O吗?怎么到目前为止跟Java好像一点关系都没有呢?嘿嘿,别急,下面我们就聊聊Java中的I/O模型~

Java中的I/O模型 首先刚刚说的大多数I/O模型在Java中都有对应的实现。为什么是大多数呢?因为信号驱动I/O模型没有相应的实现。直接上代码~

  1. 阻塞I/O 我们通常在Socket编程入门的时候会这样写,
/**
 * 阻塞IO
 * Created by liumian on 2016/11/23.
 */
public class BlockServer {

    public static void main(String[] args) {
        int port = 8080;
        try {
            ServerSocket server = new ServerSocket(port);
            Socket clientSocket = server.accept();
            //client do something
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

这就是一个阻塞IO,阻塞在ServerSocket#accept方法上面,直到有数据到达才会执行后面的代码。

  1. 非阻塞I/O与多路复用I/O 相对于阻塞I/O,代码要复杂很多。关于NIO的知识,一时半会也说不完,读者可以下去了解一下相关知识~
/**
 * 非阻塞IO
 * Created by liumian on 2016/11/23.
 */
public class NonBlockServer {

    public static void main(String[] args) {
        int port = 8080;

        Selector selector = null;
        try {
            ServerSocketChannel channel = ServerSocketChannel.open();
            channel.socket().bind(new InetSocketAddress(port));
            //设置为非阻塞IO
            channel.configureBlocking(false);
            //打开一个复用器
            selector = Selector.open();
            //注册感兴趣的事件
            channel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            e.printStackTrace();
        }

        while (true){
            try {
                selector.select();
            } catch (IOException e) {
                e.printStackTrace();
            }
            Set<SelectionKey> keySet = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keySet.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                if (key.isAcceptable()){
                    //do something
                }
            }
        }
    }

}

在NIO中出现了通道channel的概念。相对于之前阻塞IO模型中的流 - 只能单向移动(读或者写),它相当于一根水管可以双向移动(既可以写又可以读或者同时进行)。

  1. 异步I/O Java在JDK7的时候引入了异步IO(NIO2.0) 代码借鉴了这个博客 Java I/O 模型的演进,(逃

public class AsyncServer {
    public static void main(String[] args) {
        int port = 8080;
        ExecutorService executor = Executors.newCachedThreadPool();
        // create asynchronous server socket channel bound to the default group
        try (AsynchronousServerSocketChannel asynchronousServerSocketChannel = AsynchronousServerSocketChannel.open()) {
            if (asynchronousServerSocketChannel.isOpen()) {
                // set some options
                asynchronousServerSocketChannel.setOption(StandardSocketOptions.SO_RCVBUF, 4 * 1024);
                asynchronousServerSocketChannel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
                // bind the server socket channel to local address
                asynchronousServerSocketChannel.bind(new InetSocketAddress(port));
                // display a waiting message while ... waiting clients
                System.out.println("Waiting for connections ...");
                while (true) {
                    Future<AsynchronousSocketChannel> asynchronousSocketChannelFuture = asynchronousServerSocketChannel
                            .accept();
                    try {
                        final AsynchronousSocketChannel asynchronousSocketChannel = asynchronousSocketChannelFuture
                                .get();
                        Callable<String> worker = new Callable<String>() {
                            @Override
                            public String call() throws Exception {
                                String host = asynchronousSocketChannel.getRemoteAddress().toString();
                                System.out.println("Incoming connection from: " + host);
                                final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
                                // transmitting data
                                while (asynchronousSocketChannel.read(buffer).get() != -1) {
                                    buffer.flip();
                                    asynchronousSocketChannel.write(buffer).get();
                                    if (buffer.hasRemaining()) {
                                        buffer.compact();
                                    } else {
                                        buffer.clear();
                                    }
                                }
                                asynchronousSocketChannel.close();
                                System.out.println(host + " was successfully served!");
                                return host;
                            }
                        };
                        executor.submit(worker);
                    } catch (InterruptedException | ExecutionException ex) {
                        System.err.println(ex);
                        System.err.println("\n Server is shutting down ...");
                        // this will make the executor accept no new threads
                        // and finish all existing threads in the queue
                        executor.shutdown();
                        // wait until all threads are finished
                        while (!executor.isTerminated()) {
                        }
                        break;
                    }
                }
            } else {
                System.out.println("The asynchronous server-socket channel cannot be opened!");
            }
        } catch (IOException ex) {
            System.err.println(ex);
        }
    }
}


  1. 伪异步I/O 只要理解了异步I/O,那么伪异步I/O很好理解。 异步I/O无非就是在所有的操作完成之后再来通知用户线程进行后续操作,我们完全可以通过线程来伪造这种行为。
/**
 * 利用线程池来实现伪异步
 * Created by liumian on 2016/11/23.
 */
public class NAsyncServer {

    public static void main(String[] args) {
        int port = 8080;
        ExecutorService executor = Executors.newCachedThreadPool();
        try {
            ServerSocket server = new ServerSocket(port);
            while (true){
                Socket client = server.accept();
                executor.execute(new ClientHandler(client));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class ClientHandler implements Runnable{

        private Socket socket;

        public ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            //do something
        }
    }

}

总结 通过NIO、AIO我们可以获得哪些好处?

  • 获得更好的性能。通常基于块的传输要比流要更高效。
  • 避免多线程。利用多路复用IO,我们能利用一个线程管理成千上万的连接,而不用为每一个连接创建一个线程。
  • 提高CPU的利用率。不管是NIO还是AIO,都能够大大减少IO阻塞时间,从而充分的利用CPU。

从JDK的发展可以看到,从阻塞IO到非阻塞IO到异步IO,我们可以通过灵活的运用IO构建我们的高性能服务器。不过从JDK发展的过程也可以看出,往往越灵活的操作使用起来越困难,所以《Netty权威指南》作者建议直接使用成熟的NIO框架去构建我们的服务器而不是使用原生的NIO接口,这样可以避免很多陷阱。

个人感觉I/O这些知识不仅要多用,还要去想底层是怎么实现的。这样有助于我们理解为什么要这么做~ 以前刚接触异步IO的时候,总是有这些问题:谁帮我们去完成了IO操作?我如何知道IO操作何时完成?IO操作完成以后数据是放在哪里的?等等问题。后面随着学习的深入,结合操作系统、Java IO API等知识,慢慢也对IO有了自己的理解~~

检查了很多遍,感觉写的还是不够通顺,咬咬牙,硬着头皮发布(逃


参考资料 > Java NIO浅析 - 美团点评技术博客

> Java I/O 模型的演进

> 《Netty 权威指南》

标签: Java Io
共有 人打赏支持
粉丝 10
博文 15
码字总数 23707
×
那只是一股逆流
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: