文档章节

I/O模型与Java

那只是一股逆流
 那只是一股逆流
发布于 2016/11/23 17:05
字数 2649
阅读 28
收藏 0
点赞 0
评论 0

原文已同步至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 权威指南》

© 著作权归作者所有

共有 人打赏支持
那只是一股逆流
粉丝 9
博文 22
码字总数 26214
作品 0
南岸
后端工程师
Java NIO原理 图文分析及代码实现

Java NIO原理图文分析及代码实现 前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术...

囚兔
2015/04/29
0
0
Java NIO原理图文分析及代码实现

前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。可以参考:http://baik...

SunnyWu
2014/11/05
0
1
Scala入门-大数据云计算下的开发语言

Scala编程语言抓住了很多开发者的眼球。如果你粗略浏览Scala的网站,你会觉得Scala是一种纯粹的 面向对象编程语言,而又无缝地结合了命令式编程和 函数式编程风格。Christopher Diggins认为:...

liwei2000
06/30
0
0
Java NIO原理图文分析及代码实现

Java IO 在Client/Server模型中,Server往往需要同时处理大量来自Client的访问请求,因此Server端需采用支持高并发访问的架构。一种简单而又直接的解决方案是“one-thread-per-connection”。...

只想一个人静一静
2014/02/22
0
1
Java NIO原理图文分析及代码实现

前言: 最近在分析hadoop的RPC(Remote Procedure Call Protocol ,远程过程调用协议,它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议。可以参考:http://baik...

phacks
2015/08/19
0
0
java NIO原理及通信模型

Java NIO是在jdk1.4开始使用的,它既可以说成“新IO”,也可以说成非阻塞式I/O。下面是java NIO的工作原理: 由一个专门的线程来处理所有的IO事件,并负责分发。 事件驱动机制:事件到的时候...

柳哥
2015/02/15
0
4
Java NIO 机制分析(一) Java IO的演进

一、引言 Java1.4之前的早期版本,Java对I/O的支持并不完善,开发人员再开发高性能I/O程序的时候,会面临一些巨大的挑战和困难,主要有以下一些问题: (1)没有数据缓冲区,I/O性能存在问题...

宸明
04/20
0
0
select,iocp,epoll,kqueue及各种I/O复用机制

首先,介绍几种常见的I/O模型及其区别,如下: blocking I/O nonblocking I/O I/O multiplexing (select and poll) signal driven I/O (SIGIO) asynchronous I/O (the POSIX aio_functions)......

大道至簡
2014/08/04
0
1
Java 进阶(一) JVM运行时内存模型

1.JVM运行时数据区域的划分 a.程序计数器(Program Counter Register) 一块较小的内存空间,可以看作是当前线程所执行的字节码的行号指示器。每个线程拥有独立的一个计数器,如果当前执行的...

atkone
2014/08/21
0
0
再谈select, iocp, epoll,kqueue及各种I/O复用机制

首先,介绍几种常见的I/O模型及其区别,如下: blocking I/O nonblocking I/O I/O multiplexing (select and poll) signal driven I/O (SIGIO) asynchronous I/O (the POSIX aio_functions)......

开心303
2012/02/09
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Mybaties入门介绍

Mybaties和Hibernate是我们在Java开发中应用的比较多的两个ORM框架。当然,目前Mybaties正在慢慢取代Hibernate,这是因为相比较Hibernate而言Mybaties性能更好,响应更快,更加灵活。我们在开...

王子城
昨天
0
0
编程学习笔记之python深入之装饰器案例及说明文档[图]

编程学习笔记之python深入之装饰器案例及说明文档[图] 装饰器即在不对一个函数体进行任何修改,以及不改变整体的原本意思的情况下,增加函数功能的新函数,因为这个新函数对旧函数进行了装饰...

原创小博客
昨天
0
0
流利阅读笔记33-20180722待学习

黑暗中的生物:利用奇技淫巧快活生存 Daniel 2018-07-22 1.今日导读 如果让你在伸手不见五指的黑暗当中生存,你能熬过几天呢?而大千世界,无奇不有。在很多你不知道的角落,有些生物在完全黑...

aibinxiao
昨天
2
0
Hystrix降级逻辑中如何获取触发的异常

通过之前Spring Cloud系列教程中的《Spring Cloud构建微服务架构:服务容错保护(Hystrix服务降级)》一文,我们已经知道如何通过Hystrix来保护自己的服务不被外部依赖方拖垮的情况。但是实际...

程序猿DD
昨天
0
0
gin endless 热重启

r := gin.New()r.GET("/", func(c *gin.Context) {c.String(200, config.Config.Server.AppId)})s := endless.NewServer(":8080", r)s.BeforeBegin = func(add string) ......

李琼涛
昨天
0
0
JAVA模式之代理模式

平时一直在用spring,spring中最大的特效IOC和AOP,其中AOP使用的就是代理模式.闲着无聊,随手写了一个代理模式,也记录下代理模式的实现Demo. 比如现在有一个场景是:客户想要增加一个新的功能,...

勤奋的蚂蚁
昨天
0
0
ES15-JAVA API 索引管理

1.创建连接 创建连接demo package com.sean.esapi.client;import java.net.InetSocketAddress;import org.elasticsearch.action.get.GetResponse;import org.elasticsearch.clien......

贾峰uk
昨天
0
0
单点登录的设计,从单域名到多域名(经验分享)

个人实践总结,最初的的需求,多个产品线都在同一个根域名下面。 独立的用户中心分离,单独负责用户登录和用户信息获取、变更等处理逻辑。 第一步,用户登录成功,分配给用户一个memToken(令...

小海bug
昨天
0
0
合格前端第十二弹-TypeScript + 大型项目实战

写在前面 TypeScript 已经出来很久了,很多大公司很多大项目也都在使用它进行开发。上个月,我这边也正式跟进一个对集团的大型运维类项目。 项目要做的事情大致分为以下几个大模块 一站式管理...

qiangdada
昨天
3
0
gradle学习笔记

相关文档 适合新手的 gradle 自学教程合集 Gradle教程

OSC_fly
昨天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部