分布式专题-NIO框架之Netty01-Java IO 演进之路

目录导航

    • 前言
    • Java IO
      • 阻塞(Block)和非阻塞(Non-Block)
      • 同步(Synchronization)和异步(Asynchronous)
    • Java BIO 与 Java NIO
      • Java BIO(Block IO)
      • Java NIO(Non-Block IO)
      • 面向流与面向缓冲
      • 阻塞与非阻塞
      • 选择器的问世
      • NIO 和 BIO 如何影响应用程序的设计
    • Java AIO(Asynchronous IO)
      • AIO基本原理
      • AIO DEMO
    • 后记

前言

本节我们开始讲Netty,在分布式专题涉及到很多框架,诸如Zookeeper 、Dubbo 以及我们常说的Spring5、Spring Boot的底层都涉及到了Netty,不可谓不重要!

  • 什么是Netty?

简化开发一系列解决方案的集合封装IO操作的框架

  • Netty能帮我们解决什么问题?

复杂的业务场景中,没有说用一个单独IO API或者IO + 多线程来解决问题,所以Netty应运而生。

本文适合具有网络通信开发经验、具有 1-3 年 Java Web 开发经验的同学。

Netty共计分为七节,分别是:

  • 01 Java IO 演进之路
  • 02 Netty与NIO之前世今生
  • 03 Netty初体验之重构RPC框架
  • 04 Netty核心之Netty高性能之道
  • 05 Netty核心之大动脉 Pipeline与EventLoop
  • 06 Netty实战之手写消息推送系统
  • 07 Netty实战之性能调优与设计模式

本节重点:

➢ 掌握 Java 中 BIONIOAIO 之间的区别及应用场景
➢ 透彻理解阻塞(Block)与非阻塞(Non-Block)区别
➢ 透彻理解同步(Synchronization)和异步(Asynchronous)的区别

Java IO

我们知道,在Java IO模型中,有三种:

  • BIO:Block IO ,同步阻塞IO

  • NIO: Non-Block IO, 同步非阻塞IO(线程池)

  • AIO(NIO2): Async IO, 异步非阻塞IO(事件驱动,回调)

而Netty作为封装IO操作的框架,目的是提升IO操作的性能。

jdk 1.4 以前 都是BIO;1.4 之后 NIO出现,IO性能得到大幅提升(对性能要求) Netty 默认用的NIO;1.7 NIO --> NIO2(AIO)操作系统的性能,决定的IO性能(兼容问题)

阻塞(Block)和非阻塞(Non-Block)

阻塞和非阻塞是进程在访问数据的时候,数据是否准备就绪的一种处理方式,当数据没有准备的时候。

阻塞:往往需要等待缓冲区中的数据准备好过后才处理其他的事情,否则一直等待在那里。

非阻塞 : 当我们的进程访问我们的数据缓冲区的时候,如果数据没有准备好则直接返回,不会等待。如果数据已经准备好,也直接返回。

同步(Synchronization)和异步(Asynchronous)

同步和异步都是基于应用程序和操作系统处理 IO 事件所采用的方式。比如同步:是应用程序要直接参与 IO 读写的操作。异步:所有的 IO 读写交给操作系统去处理,应用程序只需要等待通知。

同步方式在处理 IO 事件的时候,必须阻塞在某个方法上面等待我们的 IO 事件完成(阻塞 IO 事件或者通过轮询 IO 事件的方式),对于异步来说,所有的 IO 读写都交给了操作系统。这个时候,我们可以去做其他的事情,并不需要去完成真正的 IO 操作,当操作完成 IO 后,会给我们的应用程序一个通知。

同步 : 阻塞到 IO 事件,阻塞到 read 或则 write。这个时候我们就完全不能做自己的事情。让读写方法加入到线程里面,然后阻塞线程来实现,对线程的性能开销比较大。

并行与并发的区别 - 转载

Java BIO 与 Java NIO

下表总结了 Java BIO(Block IO)和 NIO(Non-Block IO)之间的主要差别异。

IO模型 BIO NIO
通信 面向流(乡村公路) 面向缓冲(高速公路,多路复用技术)
处理 阻塞 IO(多线程) 非阻塞 IO(反应堆 Reactor)
触发 选择器(轮询机制)

Java BIO(Block IO)

客户端:

public class BIOClient {
     
	public static void main(String[] args) throws UnknownHostException, IOException {
     
		//要和谁进行通信,服务器IP、服务器的端口
		//一台机器的端口号是有限
		Socket client = new Socket("localhost", 8080);
		//输出 O  write();
		//不管是客户端还是服务端,都有可能write和read
		OutputStream os = client.getOutputStream();
		//生成一个随机的ID
		String name = UUID.randomUUID().toString();
		System.out.println("客户端发送数据:" + name);
		os.write(name.getBytes());
		os.close();
		client.close();
	}
}

服务端:

//同步阻塞IO模型
public class BIOServer {
     

	//服务端网络IO模型的封装对象
	ServerSocket server;
	//服务器
	public BIOServer(int port){
     
		try {
     
			//Tomcat 默认端口8080
			//只要是Java写的都这么玩,3306
			//Redis  6379
			//Zookeeper  2181
			//HBase
			//RMI
			//TCP
			server = new ServerSocket(port);
			System.out.println("BIO服务已启动,监听端口是:" + port);
		} catch (IOException e) {
     
			e.printStackTrace();
		}
	}
	
	/**
	 * 开始监听,并处理逻辑
	 * @throws IOException 
	 */
	public void listen() throws IOException{
     
		//循环监听
		while(true){
     
			//等待客户端连接,阻塞方法
			//Socket数据发送者在服务端的引用
			Socket client = server.accept();
			System.out.println(client.getPort());
			//对方法数据给我了,读 Input
			InputStream is = client.getInputStream();
			//网络客户端把数据发送到网卡,机器所得到的数据读到了JVM内中
			byte [] buff = new byte[1024];
			int len = is.read(buff);
			if(len > 0){
     
				String msg = new String(buff,0,len);
				System.out.println("收到" + msg);
			}
		}
	}
	
	public static void main(String[] args) throws IOException {
     
		new BIOServer(8080).listen();
	}
}

运行结果

服务端
分布式专题-NIO框架之Netty01-Java IO 演进之路_第1张图片
客户端
分布式专题-NIO框架之Netty01-Java IO 演进之路_第2张图片

Java NIO(Non-Block IO)

客户端同上面的bio客户端代码
服务端:

/**
 * NIO的操作过于繁琐,于是才有了Netty
 * Netty就是对这一系列非常繁琐的操作进行了封装
 */
public class NIOServerDemo {
     

    private int port = 8080;

    //准备两个东西
    //轮询器 Selector 大堂经理
    private Selector selector;
    //缓冲区 Buffer 等候区
    private ByteBuffer buffer = ByteBuffer.allocate(1024);

    //初始化完毕
    public NIOServerDemo(int port){
     
        //初始化大堂经理,开门营业
        try {
     
            this.port = port;
            ServerSocketChannel server = ServerSocketChannel.open();
            //我得告诉地址
            //IP/Port
            server.bind(new InetSocketAddress(this.port));
            //BIO 升级版本 NIO,为了兼容BIO,NIO模型默认是采用阻塞式
            server.configureBlocking(false);

            //大堂经理准备就绪,接客
            selector = Selector.open();

            //在门口翻牌子,正在营业
            server.register(selector, SelectionKey.OP_ACCEPT);

        } catch (Exception e) {
     
            e.printStackTrace();
        }
    }

    public void listen(){
     
        System.out.println("listen on " + this.port + ".");
        try {
     
            //轮询主线程

            while (true){
     
                //大堂经理再叫号
                selector.select();
                //每次都拿到所有的号子
                Set<SelectionKey> keys = selector.selectedKeys();
                Iterator<SelectionKey> iter = keys.iterator();
                //不断地迭代,就叫轮询
                //同步体现在这里,因为每次只能拿一个key,每次只能处理一种状态
                while (iter.hasNext()){
     
                    SelectionKey key = iter.next();
                    iter.remove();
                    //每一个key代表一种状态
                    //没一个号对应一个业务
                    //数据就绪、数据可读、数据可写 等等等等
                    process(key);
                }
                
            }
        } catch (IOException e) {
     
            e.printStackTrace();
        }
    }

    //具体办业务的方法,坐班柜员
    //每一次轮询就是调用一次process方法,而每一次调用,只能干一件事
    //在同一时间点,只能干一件事
    private void process(SelectionKey key) throws IOException {
     
        //针对于每一种状态给一个反应
        if(key.isAcceptable()){
     
            ServerSocketChannel server = (ServerSocketChannel)key.channel();
            //这个方法体现非阻塞,不管你数据有没有准备好
            //你给我一个状态和反馈
            SocketChannel channel = server.accept();
            //一定一定要记得设置为非阻塞
            channel.configureBlocking(false);
            //当数据准备就绪的时候,将状态改为可读
            key = channel.register(selector,SelectionKey.OP_READ);
        }
        else if(key.isReadable()){
     
            //key.channel 从多路复用器中拿到客户端的引用
            SocketChannel channel = (SocketChannel)key.channel();
            int len = channel.read(buffer);
            if(len > 0){
     
                buffer.flip();
                String content = new String(buffer.array(),0,len);
                key = channel.register(selector,SelectionKey.OP_WRITE);
                //在key上携带一个附件,一会再写出去
                key.attach(content);
                System.out.println("读取内容:" + content);
            }
        }
        else if(key.isWritable()){
     
            SocketChannel channel = (SocketChannel)key.channel();
            String content = (String)key.attachment();
            channel.write(ByteBuffer.wrap(("输出:" + content).getBytes()));
            channel.close();
        }
    }

    public static void main(String[] args) {
     
        new NIOServerDemo(8080).listen();
    }
}

运行结果

首先启动服务端,然后可以不断的启动客户端模拟多次发送的场景

服务端
分布式专题-NIO框架之Netty01-Java IO 演进之路_第3张图片
客户端效果同BIO Client效果

面向流与面向缓冲

Java NIO 和 BIO 之间第一个最大的区别是,BIO 是面向流的,NIO 是面向缓冲区的。 Java BIO 面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方。此外,它不能前后移动流中的数据。

如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。 Java NIO 的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。

阻塞与非阻塞

Java BIO 的各种流是阻塞的。这意味着,当一个线程调用 read()write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了。

Java NIO 的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取。而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞 IO 的空闲时间用于在其它通道上执行 IO 操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。

选择器的问世

Java NIO 的选择器(Selector)允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。

NIO 和 BIO 如何影响应用程序的设计

无论您选择 BIO 或 NIO 工具箱,可能会影响您应用程序设计的以下几个方面:

  • 对 NIO 或 BIO 类的 API 调用
  • 数据处理逻辑
  • 用来处理数据的线程数
  1. API 调用

当然,使用 NIO 的 API 调用时看起来与使用 BIO 时有所不同,但这并不意外,因为并不是仅从一个 InputStream逐字节读取,而是数据必须先读入缓冲区再处理。

  1. 数据处理

使用纯粹的 NIO 设计相较 BIO 设计,数据处理也受到影响。

在 BIO 设计中,我们从 InputStreamReader 逐字节读取数据。假设你正在处理一基于行的文本数据流,例如:

有如下一段文本:

Name:Tom
Age:18
Email: [email protected]
Phone:13888888888

该文本行的流可以这样处理:

FileInputStream input = new FileInputStream("d://info.txt");
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
//
String nameLine = reader.readLine();
String ageLine = reader.readLine();
String emailLine = reader.readLine();
String phoneLine = reader.readLine();

请注意处理状态由程序执行多久决定。换句话说,一旦 reader.readLine()方法返回,你就知道肯定文本行就已读完,readline()阻塞直到整行读完,这就是原因。你也知道此行包含名称;同样,第二个 readline()调用返回的时候,你知道这行包含年龄等。 正如你可以看到,该处理程序仅在有新数据读入时运行,并知道每步的数据是什么。一旦正在运行的线程已处理过读入的某些数据,该线程不会再回退数据(大多如此)。下图也说明了这条原则:

分布式专题-NIO框架之Netty01-Java IO 演进之路_第4张图片
(Java BIO: 从一个阻塞的流中读数据) 而一个 NIO 的实现会有所不同,下面是一个简单的例子:

ByteBuffer buffer = ByteBuffer.allocate(48);

int bytesRead = inChannel.read(buffer);

注意第二行,从通道读取字节到 ByteBuffer。当这个方法调用返回时,你不知道你所需的所有数据是否在缓冲区内。

你所知道的是,该缓冲区包含一些字节,这使得处理有点困难。

假设第一次 read(buffer)调用后,读入缓冲区的数据只有半行,例如,“Name:An”,你能处理数据吗?显然不能,需要等待,直到整行数据读入缓存,在此之前,对数据的任何处理毫无意义。

所以,你怎么知道是否该缓冲区包含足够的数据可以处理呢?

好了,你不知道。发现的方法只能查看缓冲区中的数据。其结果是,在你知道所有数据都在缓冲区里之前,你必须检查几次缓冲区的数据。这不仅效率低下,而且可以使程序设计方案杂乱不堪。例如:

ByteBuffer buffer = ByteBuffer.allocate(48);
int bytesRead = inChannel.read(buffer);
while(!bufferFull(bytesRead)) {
     
	bytesRead = inChannel.read(buffer);
}

bufferFull()方法必须跟踪有多少数据读入缓冲区,并返回真或假,这取决于缓冲区是否已满。换句话说,如果缓冲区准备好被处理,那么表示缓冲区满了。

bufferFull()方法扫描缓冲区,但必须保持在 bufferFull()方法被调用之前状态相同。如果没有,下一个读入缓冲区的数据可能无法读到正确的位置。这是不可能的,但却是需要注意的又一问题。

如果缓冲区已满,它可以被处理。如果它不满,并且在你的实际案例中有意义,你或许能处理其中的部分数据。

但是许多情况下并非如此。下图展示了“缓冲区数据循环就绪”:

分布式专题-NIO框架之Netty01-Java IO 演进之路_第5张图片

  1. 设置处理线程数

NIO 可让您只使用一个(或几个)单线程管理多个通道(网络连接或文件),但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。

如果需要管理同时打开的成千上万个连接,这些连接每次只是发送少量的数据,例如聊天服务器,实现 NIO 的服务器可能是一个优势。同样,如果你需要维持许多打开的连接到其他计算机上,如 P2P 网络中,使用一个单独的线程来管理你所有出站连接,可能是一个优势。一个线程多个连接的设计方案如:

分布式专题-NIO框架之Netty01-Java IO 演进之路_第6张图片
Java NIO: 单线程管理多个连接

如果你有少量的连接使用非常高的带宽,一次发送大量的数据,也许典型的 IO 服务器实现可能非常契合。下图说明了一个典型的 IO 服务器设计:
分布式专题-NIO框架之Netty01-Java IO 演进之路_第7张图片
Java BIO: 一个典型的 IO 服务器设计- 一个连接通过一个线程处理。

Java AIO(Asynchronous IO)

jdk1.7 (NIO2)才是实现真正的异步 AIO、把 IO 读写操作完全交给操作系统,学习了 linux epoll 模式,下面我们来做一些演示。

AIO基本原理

服务端:AsynchronousServerSocketChannel

客服端:AsynchronousSocketChannel

用户处理器:CompletionHandler 接口,这个接口实现应用程序向操作系统发起 IO 请求,当完成后处理具体逻辑,否则做自己该做的事情,“真正”的异步IO需要操作系统更强的支持。在IO多路复用模型中,事件循环将文件句柄的状态事件通知给用户线程,由用户线程自行读取数据、处理数据。而在异步IO模型中,当用户线程收到通知时,数据已经被内核读取完毕,并放在了用户线程指定的缓冲区内,内核在IO完成后通知用户线程直接使用即可。异步IO模型使用了Proactor设计模式实现了这一机制,如下图所示:

分布式专题-NIO框架之Netty01-Java IO 演进之路_第8张图片

AIO DEMO

服务端代码:

/**
 * AIO服务端
 */
public class AIOServer {
     

    private final int port;

    public static void main(String args[]) {
     
        int port = 8000;
        new AIOServer(port);
    }

    public AIOServer(int port) {
     
        this.port = port;
        listen();
    }

    private void listen() {
     
        try {
     
            ExecutorService executorService = Executors.newCachedThreadPool();
            AsynchronousChannelGroup threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
            //开门营业
            //工作线程,用来侦听回调的,事件响应的时候需要回调
            final AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(threadGroup);
            server.bind(new InetSocketAddress(port));
            System.out.println("服务已启动,监听端口" + port);

            //准备接受数据
            server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>(){
     
                final ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
                //实现completed方法来回调
                //由操作系统来触发
                //回调有两个状态,成功
                public void completed(AsynchronousSocketChannel result, Object attachment){
     
                    System.out.println("IO操作成功,开始获取数据");
                    try {
     
                        buffer.clear();
                        result.read(buffer).get();
                        buffer.flip();
                        result.write(buffer);
                        buffer.flip();
                    } catch (Exception e) {
     
                        System.out.println(e.toString());
                    } finally {
     
                        try {
     
                            result.close();
                            server.accept(null, this);
                        } catch (Exception e) {
     
                            System.out.println(e.toString());
                        }
                    }

                    System.out.println("操作完成");
                }

                @Override
                //回调有两个状态,失败
                public void failed(Throwable exc, Object attachment) {
     
                    System.out.println("IO操作是失败: " + exc);
                }
            });

            try {
     
                Thread.sleep(Integer.MAX_VALUE);
            } catch (InterruptedException ex) {
     
                System.out.println(ex);
            }
        } catch (IOException e) {
     
            System.out.println(e);
        }
    }
}

客户端代码:

/**
 * AIO客户端
 */
public class AIOClient {
     
    private final AsynchronousSocketChannel client;

    public AIOClient() throws Exception{
     
        client = AsynchronousSocketChannel.open();
    }

    public void connect(String host,int port)throws Exception{
     
        client.connect(new InetSocketAddress(host,port),null,new CompletionHandler<Void,Void>() {
     
            @Override
            public void completed(Void result, Void attachment) {
     
                try {
     
                    client.write(ByteBuffer.wrap("这是一条测试数据".getBytes())).get();
                    System.out.println("已发送至服务器");
                } catch (Exception ex) {
     
                    ex.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
     
                exc.printStackTrace();
            }
        });
        final ByteBuffer bb = ByteBuffer.allocate(1024);
        client.read(bb, null, new CompletionHandler<Integer,Object>(){
     

                    @Override
                    public void completed(Integer result, Object attachment) {
     
                        System.out.println("IO操作完成" + result);
                        System.out.println("获取反馈结果" + new String(bb.array()));
                    }

                    @Override
                    public void failed(Throwable exc, Object attachment) {
     
                        exc.printStackTrace();
                    }
                }
        );

        try {
     
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException ex) {
     
            System.out.println(ex);
        }

    }

    public static void main(String args[])throws Exception{
     
        new AIOClient().connect("localhost",8000);
    }
}

执行结果:

服务端
分布式专题-NIO框架之Netty01-Java IO 演进之路_第9张图片
客户端
分布式专题-NIO框架之Netty01-Java IO 演进之路_第10张图片

后记

最后,对各 IO 模型对比与总结:

属性 同步阻塞 IO(BIO) 伪异步 IO 非阻塞 IO(NIO) 异步 IO(AIO)
客户端数:IO 线程数 1:1 M:N(M>=N) M:1 M:0
阻塞类型 阻塞 阻塞 非阻塞 非阻塞
同步 同步 同步 同步(多路复用) 异步
API 使用难度 简单 简单 复杂 一般
调试难度 简单 简单 复杂 复杂

附赠电子书:《Netty权威指南.pdf》
链接:https://pan.baidu.com/s/1KGH2dSfeP0cKlQDAoM0Ojw
提取码: l3ln

更多架构知识,欢迎关注本套Java系列文章:Java架构师成长之路

你可能感兴趣的:(分布式专题,netty,bio,nio,aio,同步与异步)