zoukankan      html  css  js  c++  java
  • 【转】Java NIO(二)

    传统的并发型服务器设计是利用阻塞型网络I/O 以多线程的模式来实现的,然而由于系统常常在进行网络读写时处于阻塞状态,会大大影响系统的性能;自Java1. 4 开始引入了NIO(新I/O) API,通过使用非阻塞型I/O,实现流畅的网络读写操作,为开发高性能并发型服务器程序提供了一个很好的解决方案,这就是java nio。

    首先来看下传统的阻塞型网络 I/O的不足

    Java 平台传统的I/O 系统都是基于Byte(字节)和Stream(数据流)的,相应的I/O 操作都是阻塞型的,所以服务器程序也采用阻塞型I/O 进行数据的读、写操作。本文以TCP长连接模式来讨论并发型服务器的相关设计,为了实现服务器程序的并发性要求,系统由一个单独的主线程来监听用户发起的连接请求,一直处于阻塞状态;当有用户连接请求到来时,程序都会启一个新的线程来统一处理用户数据的读、写操作。

    这种模式的优点是简单、实用、易管理;然而缺点也是显而易见的:由于是为每一个客户端分配一个线程来处理输入、输出数据,其线程与客户机的比例近似为1:1,随着线程数量的不断增加,服务器启动了大量的并发线程,会大大加大系统对线程的管理开销,这将成为吞吐量瓶颈的主要原因;其次由于底层的I/O 操作采用的同步模式,I/O 操作的阻塞管理粒度是以服务于请求的线程为单位的,有可能大量的线程会闲置,处于盲等状态,造成I/O资源利用率不高,影响整个系统的性能。

    对于并发型服务器,系统用在阻塞型I/O 等待和线程间切换的时间远远多于CPU 在内存中处理数据的时间,因此传统的阻塞型I/O 已经成为制约系统性能的瓶颈。Java1.4 版本后推出的NIO 工具包,提供了非阻塞型I/O 的异步输入输出机制,为提高系统的性能提供了可实现的基础机制。

    NIO 包及工作原理

    针对传统I/O 工作模式的不足,NIO 工具包提出了基于Buffer(缓冲区)、Channel(通道)、Selector(选择器)的新模式;Selector(选择器)、可选择的Channel(通道)SelectionKey(选择键)配合起来使用,可以实现并发的非阻塞型I/O 能力。

    NIO 工具包的成员

    • Buffer(缓冲器)
      Buffer 类是一个抽象类,它有7 个子类分别对应于七种基本的数据类型:ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer 和ShortBuffer。每一个Buffer对象相当于一个数据容器,可以把它看作内存中的一个大的数组,用来存储和提取所有基本类型(boolean 型除外)的数据。Buffer 类的核心是一块内存区,可以直接对其执行与内存有关的操作,利用操作系统特性和能力提高和改善Java 传统I/O 的性能。
    • Channel(通道)
      Channel 被认为是NIO 工具包的一大创新点,是(Buffer)缓冲器和I/O 服务之间的通道,具有双向性,既可以读入也可以写出,可以更高效的传递数据。我们这里主要讨论的是ServerSocketChannel 和SocketChannel,它们都继承了SelectableChannel,是可选择的通道,分别可以工作在同步和异步两种方式下(这里的可选择不是指可以选择两种工作方式,而是指可以有选择的注册自己感兴趣的事件)。当通道工作在同步方式时,它的功能和编程方法与传统的ServerSocket、Socket 对象相似;当通道工作在异步工作方式时,进行输入输出处理不必等到输入输出完毕才返回,并且可以将其感兴趣的(如:接受操作、连接操作、读出操作、写入操作)事件注册到Selector 对象上,与Selector 对象协同工作可以更有效率的支持和管理并发的网络套接字连接。
    • Selector(选择器)
      各类 Buffer 是数据的容器对象;各类Channel 实现在各类Buffer 与各类I/O 服务间传输数据。Selector 是实现并发型非阻塞I/O 的核心,各种可选择的通道将其感兴趣的事件注册到Selector 对象上,Selector 在一个循环中不断轮循监视这各些注册在其上的Socket 通道。为ServerSocketChannel 监控接收客户端连接就绪事件,为 SocketChannel 监控连接服务器就绪,读就绪和写就绪事件。
    • ServerSocketChannel
      ServerSocket 的替代类,支持阻塞通信与非阻塞通信。
    • SocketChannel
      Socket 的替代类,支持阻塞通信与非阻塞通信。
    • SelectionKey
      SelectionKey 类则封装了SelectableChannel 对象在Selector 中的注册信息。当Selector 监测到在某个注册的SelectableChannel 上发生了感兴趣的事件时,自动激活产生一个SelectionKey对象,这个对象中记录了哪一个SelectableChannel 上发生了哪种事件,通过对被激活的SelectionKey 的分析,外界可以知道每个SelectableChannel 发生的具体事件类型,进行相应的处理。当一个 SelectionKey 对象位于Selector 对象的 selected-keys 集合中时,就表示与这个 SelectionKey 对象相关的事件发生了。
    • 在SelectionKey 类中几个静态常量
      SelectionKey.OP_ACCEPT     ->   客户端连接就绪事件 等于监听serversocket.accept()返回一个socket
      SelectionKey.OP_CONNECT  ->   准备连接服务器就绪 跟上面类似,只不过是对于socket的 相当于监听了 socket.connect()
      SelectionKey.OP_READ        ->   读就绪事件, 表示输入流中已经有了可读数据, 可以执行读操作了
      SelectionKey.OP_WRITE       ->   写就绪事件

     

    在使用传统的ServerSocket和Socket的时候 很多时候程序是会阻塞的。比如 serversocket.accept() , socket.getInputStream().read() 的时候都会阻塞 。

    accept()方法除非等到客户端socket的连接或者被异常中断 否则会一直等待下去,read()方法也是如此 除非在输入流中有了足够的数据,否则该方法也会一直等待下去知道数据的到来。在ServerSocket与Socket的方式中 服务器端往往要为每一个客户端(socket)分配一个线程,而每一个线程都有可能处于长时间的阻塞状态中.而过多的线程也会影响服务器的性能,在JDK1.4引入了非阻塞的通信方式,这样使得服务器端只需要一个线程就能处理所有客户端socket的请求。

     

    NIO 工作原理

    通过上面的讨论,我们可以看出在并发型服务器程序中使用NIO,实际上是通过网络事件驱动模型实现的。我们应用Select 机制,不用为每一个客户端连接新启线程处理,而是将其注册到特定的Selector 对象上,这就可以在单线程中利用Selector 对象管理大量并发的网络连接,更好的利用了系统资源;采用非阻塞I/O 的通信方式,不要求阻塞等待I/O 操作完成即可返回,从而减少了管理I/O 连接导致的系统开销,大幅度提高了系统性能。

    当有读或写等任何注册的事件发生时,可以从Selector 中获得相应的SelectionKey , 从SelectionKey 中可以找到发生的事件和该事件所发生的具体的SelectableChannel,以获得客户端发送过来的数据。由于在非阻塞网络I/O 中采用了事件触发机制,处理程序可以得到系统的主动通知,从而可以实现底层网络I/O 无阻塞、流畅地读写,而不像在原来的阻塞模式下处理程序需要不断循环等待。使用NIO,可以编写出性能更好、更易扩展的并发型服务器程序。

    并发型服务器程序的实现代码

    应用 NIO 工具包,基于非阻塞网络I/O 设计的并发型服务器程序与以往基于阻塞I/O 的实现程序有很大不同,在使用非阻塞网络I/O 的情况下,程序读取数据和写入数据的时机不是由程序员控制的,而是Selector 决定的。下面便给出基于非阻塞网络I/O 的并发型服务器程序的核心代码片段:

    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    import java.util.Set;
    
    public class NIOServer {
    
        /*标识数字*/
        private int flag = 0;
        /*缓冲区大小*/
        private int BLOCK = 4096;
        /*接受数据缓冲区*/
        private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
        /*发送数据缓冲区*/
        private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
        private Selector selector;
    
        public NIOServer(int port) throws IOException {
            // 打开服务器套接字通道  
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 服务器配置为非阻塞  
            serverSocketChannel.configureBlocking(false);
            // 检索与此通道关联的服务器套接字  
            ServerSocket serverSocket = serverSocketChannel.socket();
            // 进行服务的绑定  
            serverSocket.bind(new InetSocketAddress(port));
            // 通过open()方法找到Selector  
            selector = Selector.open();
            // 注册到selector,等待连接  
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("Server Start----8888:");
        }
    
        // 监听  
        private void listen() throws IOException {
            while (true) {
                // 应用Select机制轮循是否有用户感兴趣的新的网络事件发生,当没有新的网络事件发生时,此方法会阻塞,直到有新的网络事件发生为止。
                selector.select();
                // 返回此选择器的已选择键集。  
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                System.out.println("selectionKeys size -> " + selectionKeys.size());
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    handleKey(selectionKey);
                }
            }
        }
    
        // 处理请求  
        private void handleKey(SelectionKey selectionKey) throws IOException {
            // 接受请求  
            ServerSocketChannel server = null;
            SocketChannel client = null;
            String receiveText;
            String sendText;
            int count = 0;
            // 测试此键的通道是否已准备好接受新的套接字连接。  
            if (selectionKey.isAcceptable()) {
                System.out.println("------------- isAcceptable");
                // 返回为之创建此键的通道。  
                server = (ServerSocketChannel) selectionKey.channel();
                // 接受到此通道套接字的连接。  
                // 此方法返回的套接字通道(如果有)将处于阻塞模式。  
                client = server.accept();
                // 配置为非阻塞  
                client.configureBlocking(false);
                // 注册到selector,等待连接  
                client.register(selector, SelectionKey.OP_READ);
            }
            else if (selectionKey.isReadable()) {
                System.out.println("------------- isReadable");
                // 返回为之创建此键的通道。  
                client = (SocketChannel) selectionKey.channel();
                //将缓冲区清空以备下次读取  
                receivebuffer.clear();
                //读取服务器发送来的数据到缓冲区中  
                count = client.read(receivebuffer);
                if (count > 0) {
                    receiveText = new String(receivebuffer.array(), 0, count);
                    System.out.println("服务器端接受客户端数据--:" + receiveText);
                    client.register(selector, SelectionKey.OP_WRITE);
                }
            }
            else if (selectionKey.isWritable()) {
                System.out.println("------------- isWritable");
                //将缓冲区清空以备下次写入  
                sendbuffer.clear();
                // 返回为之创建此键的通道。  
                client = (SocketChannel) selectionKey.channel();
                sendText = "message from server--" + flag++;
                //向缓冲区中输入数据  
                sendbuffer.put(sendText.getBytes());
                //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                sendbuffer.flip();
                //输出到通道  
                client.write(sendbuffer);
                System.out.println("服务器端向客户端发送数据--:" + sendText);
                client.register(selector, SelectionKey.OP_READ);
            }
        }
    
        /** 
         * @param args 
         * @throws IOException 
         */
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub  
            int port = 8888;
            NIOServer server = new NIOServer(port);
            server.listen();
        }
    }
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    import java.util.Set;
    
    public class NIOClient {
    
        /*标识数字*/
        private static int flag = 0;
        /*缓冲区大小*/
        private static int BLOCK = 4096;
        /*接受数据缓冲区*/
        private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
        /*发送数据缓冲区*/
        private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
        /*服务器端地址*/
        private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress("localhost", 8888);
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub  
            // 打开socket通道  
            SocketChannel socketChannel = SocketChannel.open();
            // 设置为非阻塞方式  
            socketChannel.configureBlocking(false);
            // 打开选择器  
            Selector selector = Selector.open();
            // 注册连接服务端socket动作  
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            // 连接  
            socketChannel.connect(SERVER_ADDRESS);
            // 分配缓冲区大小内存  
    
            Set<SelectionKey> selectionKeys;
            Iterator<SelectionKey> iterator;
            SelectionKey selectionKey;
            SocketChannel client;
            String receiveText;
            String sendText;
            int count = 0;
    
            while (true) {
                //选择一组键,其相应的通道已为 I/O 操作准备就绪。  
                //此方法执行处于阻塞模式的选择操作。  
                selector.select();
                //返回此选择器的已选择键集。  
                selectionKeys = selector.selectedKeys();
                //System.out.println(selectionKeys.size());  
                iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    selectionKey = iterator.next();
                    if (selectionKey.isConnectable()) {
                        System.out.println("client connect");
                        client = (SocketChannel) selectionKey.channel();
                        // 判断此通道上是否正在进行连接操作。  
                        // 完成套接字通道的连接过程。  
                        if (client.isConnectionPending()) {
                            client.finishConnect();
                            System.out.println("完成连接!");
                            sendbuffer.clear();
                            sendbuffer.put("Hello,Server".getBytes());
                            sendbuffer.flip();
                            client.write(sendbuffer);
                        }
                        client.register(selector, SelectionKey.OP_READ);
                    }
                    else if (selectionKey.isReadable()) {
                        client = (SocketChannel) selectionKey.channel();
                        //将缓冲区清空以备下次读取  
                        receivebuffer.clear();
                        //读取服务器发送来的数据到缓冲区中  
                        count = client.read(receivebuffer);
                        if (count > 0) {
                            receiveText = new String(receivebuffer.array(), 0, count);
                            System.out.println("客户端接受服务器端数据--:" + receiveText);
                            client.register(selector, SelectionKey.OP_WRITE);
                        }
    
                    }
                    else if (selectionKey.isWritable()) {
                        sendbuffer.clear();
                        client = (SocketChannel) selectionKey.channel();
                        sendText = "message from client--" + (flag++);
                        sendbuffer.put(sendText.getBytes());
                        //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位  
                        sendbuffer.flip();
                        client.write(sendbuffer);
                        System.out.println("客户端向服务器端发送数据--:" + sendText);
                        client.register(selector, SelectionKey.OP_READ);
                    }
                }
                selectionKeys.clear();
            }
        }
    }

    从上面对代码可以看出,使用非阻塞性I/O进行并发型服务器程序设计分三个部分:

    1. 向Selector对象注册感兴趣的事件。
    2. 从Selector中获取所感兴趣的事件。
    3. 根据不同的事件进行相应的处理。

    结语

    通过使用NIO 工具包进行并发型服务器程序设计,一个或者很少几个Socket 线程就可以处理成千上万个活动的Socket 连接,大大降低了服务器端程序的开销;同时网络I/O 采取非阻塞模式,线程不再在读或写时阻塞,操作系统可以更流畅的读写数据并可以更有效地向CPU 传递数据进行处理,以便更有效地提高系统的性能。

     

  • 相关阅读:
    Python【第五篇】模块、包、常用模块
    Python【第四篇】函数、内置函数、递归、装饰器、生成器和迭代器
    TCP三次握手、四次挥手
    分别用postman和python做post请求接口功能测试
    Python【第三篇】文件操作、字符编码
    Python【第二篇】运算符及优先级、数据类型及常用操作、深浅拷贝
    Python【第一篇】python安装、pip基本用法、变量、输入输出、流程控制、循环
    oracle在windows(含客户端工具pl/sql安装)下安装
    Python【初识篇】简介
    Web jsp开发自学——ajax+servlet+echarts+json+gson 实现ajax传输servlert和echarts的数据,可视化结果
  • 原文地址:https://www.cnblogs.com/xuekyo/p/2868387.html
Copyright © 2011-2022 走看看