JAVA:NIO初步了解

  • 简介：

Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。

Java NIO: Channels and Buffers（通道和缓冲区）

标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。

Java NIO: Non-blocking IO（非阻塞IO）

Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。

Java NIO: Selectors（选择器）

Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

  • 工作原理：
  1. 阻塞IO工作:

　　　　阻塞I/O在调用InputStream.read()方法时是阻塞的，它会一直等到数据到来时（或超时）才会返回；

　　　　同样，在调用ServerSocket.accept()方法时，也会一直阻塞到有客户端连接才会返回，每个客户端连接过来后，服务端都会启动一个线程去处理该客户端的请求。

　　　　阻塞I/O的通信模型示意图如下：

　　　　

　　阻塞I/O存在一些缺点：
　　　　1. 当客户端多时，会创建大量的处理线程且每个线程都要占用栈空间和一些CPU时间；
　　　　2. 阻塞可能带来频繁的上下文切换，且大部分上下文切换可能是无意义的。

  1. 非阻塞IO工作：

　　Java NIO是在jdk1.4开始使用的，它既可以说成“新I/O”，也可以说成非阻塞式I/O。
　　　　1. 由一个专门的线程来处理所有的 IO 事件，并负责分发。 
　　　　2. 事件驱动机制：事件到的时候触发，而不是同步的去监视事件。 
　　　　3. 线程通讯：线程之间通过 wait,notify 等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。

　　

  • 示例用法:
  1. 　　客户端：

　　　　

　　NIOClient.java

package com.niotest;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
    /**
     * Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。
     * ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。
     * */
    public void listen(int port) throws IOException{
        // Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。
        ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
        // 为什么使用Selector?
        // 仅用单个线程来处理多个Channels的好处是，只需要更少的线程来处理通道。
        // 事实上，可以只用一个线程处理所有的通道。
        // 对于操作系统来说，线程之间上下文切换的开销很大，而且每个线程都要占用系统的一些资源（如内存）。因此，使用的线程越少越好。
        // 但是，需要记住，现代的操作系统和CPU在多任务方面表现的越来越好，所以多线程的开销随着时间的推移，变得越来越小了。
        // 实际上，如果一个CPU有多个内核，不使用多任务可能是在浪费CPU能力。
        // Selector能够处理多个通道就足够了。
        // Selector的创建:通过调用Selector.open()方法创建一个Selector
        Selector selector = Selector.open();

        // 向Selector注册通道:为了将Channel和Selector配合使用，必须将channel注册到selector上。通过SelectableChannel.register()方法来实现。
        // 设置通道为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 将该通道对应的ServerSocket绑定到port端口
        serverSocketChannel.socket().bind(new InetSocketAddress(port));
        // 注册该事件后，当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
        serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);

        // 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
        System.out.println("服务端启动成功 ... ");
        while (true) {
             //当注册的事件到达时，方法返回；否则,该方法会一直阻塞
            selector.select();
            // 获得selector中选中的项的迭代器，选中的项为注册的事件
            Iterator iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key=(SelectionKey)iterator.next();
                // 删除已选的key,以防重复处理
                iterator.remove();
                // 客户端请求连接事件
                if(key.isAcceptable()){
                    ServerSocketChannel serverChannel=(ServerSocketChannel) key.channel();
                    // 获得和客户端连接的通道
                    SocketChannel clientConnectChannel = serverChannel.accept();
                    // 设置成非阻塞
                    clientConnectChannel.configureBlocking(false);
                    //在这里可以给客户端发送信息哦
                    clientConnectChannel.write(ByteBuffer.wrap(new String("向客户端发送了一条信息").getBytes()));
                    //在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
                    clientConnectChannel.register(selector, SelectionKey.OP_READ);
                }
                // 获得了可读的事件
                else if(key.isReadable()){
                    // 服务器可读取消息,得到事件发生的Socket通道
                    SocketChannel channel = (SocketChannel)key.channel();  

                    // 创建读取的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(64);  

                    try{
                        channel.read(buffer);
                        byte[] data = buffer.array();
                        String msg = new String(data).trim();
                        System.out.println("服务端收到信息："+msg);
                        ByteBuffer outBuffer = ByteBuffer.wrap("我（服务器端）已经接收到客户端消息".getBytes());
                        // 将消息回送给客户端
                        channel.write(outBuffer);
                    }catch(IOException ex){
                        ex.printStackTrace();
                    }catch(Exception ex){
                        ex.printStackTrace();
                    }
                }

            }
        }
    }

}

Main.java

package com.niotest;

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        NIOServer server=new NIOServer();
        server.listen(8999);
    }
}
  1. 　　服务器端：

　　　　

NIOClient.java

package com.niotest;

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;

public class NIOClient
{
    public void listen(String ip,int port) throws IOException
    {
        // 获得一个Socket通道
        SocketChannel socketChannel=SocketChannel.open();
        // 设置为非阻塞
        socketChannel.configureBlocking(false);
        // 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
        //用channel.finishConnect();才能完成连接
        socketChannel.connect(new InetSocketAddress(ip,port));  

        // 获得一个通道管理器
        Selector selector=Selector.open();
        // 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
        socketChannel.register(selector, SelectionKey.OP_CONNECT);

        // 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
         // 轮询访问selector
        while (true) {
            selector.select();
            // 获得selector中选中的项的迭代器
            Iterator ite = selector.selectedKeys().iterator();
            while (ite.hasNext()) {
                SelectionKey key = (SelectionKey) ite.next();
                // 删除已选的key,以防重复处理
                ite.remove();
                // 连接事件发生
                if (key.isConnectable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 如果正在连接，则完成连接
                    if(channel.isConnectionPending()){
                        channel.finishConnect();
                    }
                    // 设置成非阻塞
                    channel.configureBlocking(false);  

                    //在这里可以给服务端发送信息哦
                    channel.write(ByteBuffer.wrap(new String("向服务端发送了一条信息").getBytes()));
                    //在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
                    channel.register(selector, SelectionKey.OP_READ);
                }
                // 获得了可读的事件
                else if (key.isReadable()) {
                    // 服务器可读取消息,得到事件发生的Socket通道
                    SocketChannel channel = (SocketChannel)key.channel();
                    // 创建读取的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(64);
                    channel.read(buffer);
                    byte[] data = buffer.array();
                    String msg = new String(data).trim();
                    System.out.println("客户端接收到服务器端消息："+msg);

//                    ByteBuffer outBuffer = ByteBuffer.wrap("我（客户端）已经收到服务器端消息".getBytes());
//                    // 将消息回送给服务器端
//                    channel.write(outBuffer);
                }  

            }  

        }
    }
}

Main.java

package com.niotest;

import java.io.IOException;

public class Main {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        NIOClient client=new NIOClient();
        client.listen("127.0.0.1", 8999);
    }

}
  1. 　　测试：

　　客户端结果：　　

客户端接收到服务器端消息：向客户端发送了一条信息
客户端接收到服务器端消息：我（服务器端）已经接收到客户端消息

　　服务器端结果：　　

服务端启动成功 ...
服务端收到信息：向服务端发送了一条信息
  • 参考资料：

http://tutorials.jenkov.com/java-nio/index.html

http://ifeve.com/java-nio-all/

http://ifeve.com/selectors/

http://ifeve.com/server-socket-channel/

http://www.iteye.com/magazines/132-Java-NIO

  • 声明：

本编学习主要参考：http://weixiaolu.iteye.com/blog/1479656

时间： 2024-09-30 05:22:23

JAVA:NIO初步了解的相关文章

Java NIO 与 基于reactor设计模式的事件处理模型

Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知道,系统运行的性能瓶颈通常在I/O读写,包括对端口和文件的操作上,过去,在打开一个I/O通道后,read()将一直等待在端口一边读取字节内容,如果没有内容进来,read()也是傻傻的等,这会影响我们程序继续做其他事情,那么改进做法就是开设线程,让线程去等待,但是这样做也是相当耗费资源的. Java NIO非堵塞技术实际是采取Reactor模式,或者说是Observer模式为我们监察I/O端口,如果有内容进来,会自动通知我们,这样,我们

Java NIO SocketChannel客户端例子（支持连接失败后自动重连）

这两天想找找标题里说的这个示例代码,发现网上这么多教程,连怎么样实现自动重连都不讲,所以把自己写的例子贴上来.仅仅使用递归,不使用多线程,就可以实现初步的目的: import java.io.IOException; import java.net.ConnectException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; impor

Java NIO （五） 管道 (Pipe)

Java NIO 管道是2个线程之间的单向数据连接.Pipe有一个source通道和一个sink通道.数据会被写到sink通道,从source通道读取. 如下图: 向管道写数据: 从管道读数据: 1. 从读取管道的数据,需要访问source通道. 2. 调用source通道的read()方法来读取数据

Java NIO中的缓冲区Buffer（一）缓冲区基础

什么是缓冲区(Buffer) 定义 简单地说就是一块存储区域,哈哈哈,可能太简单了,或者可以换种说法,从代码的角度来讲(可以查看JDK中Buffer.ByteBuffer.DoubleBuffer等的源码),Buffer类内部其实就是一个基本数据类型的数组,以及对这个缓冲数组的各种操作: 常见的缓冲区如ByteBuffer.IntBuffer.DoubleBuffer...内部对应的数组依次是byte.int.double... 与通道的关系 在Java NIO中,缓冲区主要是跟通道(Chann

Java NIO通信框架在电信领域的实践

Java NIO通信框架在电信领域的实践 此文配图有错,华为电信软件V1版逻辑架构图与华为电信软件V2 MVC版逻辑架构图两张配图是同一张啊 另:我觉得作者在本文中遇到由于同步io引起的历史遗留问题更多的是架构的问题,在作架构时就需要考虑到同步io引起的阻塞问题,我觉得比较好的解决方案是使用排队的方式来下发请求,而不是每次下发请求都启一个线程,这样如果对方还是响应慢的话即使是用nio也是解决不了问题的.

java nio

NIO 是java nonblocking(非阻塞) IO 的简称,在jdk1.4 里提供的新api .Sun 官方标榜的特性如下: 为所有的原始类型提供(Buffer)缓存支持.字符集编码解码解决方案. Channel :一个新的原始I/O 抽象. 支持锁和内存映射文件的文件访问接口. 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O . Java NIO非堵塞应用通常适用用在I/O读写等方面,我们知道,系统运行的性能瓶颈通常在I/O读写,包括对端口和文件的操作上,之前,在打开

JAVA NIO 内存映射（转载）

原文地址:http://blog.csdn.net/fcbayernmunchen/article/details/8635427 Java类库中的NIO包相对于IO 包来说有一个新功能是内存映射文件,日常编程中并不是经常用到,但是在处理大文件时是比较理想的提高效率的手段.本文我主要想结合操作系统中(OS)相关方面的知识介绍一下原理. 在传统的文件IO操作中,我们都是调用操作系统提供的底层标准IO系统调用函数 read().write() ,此时调用此函数的进程(在JAVA中即java进程)由当

java nio 大白话描述（一）

java nio基本上常用的组件,selector,channel,buffer.这三个,其他的可以用到的时候再去参考就可以了. 看一本书的时候,基本看前三章或者四章基础知识,剩下的,实际生产中用到了再去看就可以. 大白话解释这三个重要的单词 Channel: Java的nio中,channel其实是用于传输的,也可以说是管道,是一个工具,可以对比一下io中的流,很类似.但是io中的流都是单向的,但是channel通道是双向的,就是这个通道里既可以读,也可以往里面写.这个channel跟buff

Java NIO -- 管道 (Pipe)

Java NIO 管道是2个线程之间的单向数据连接. Pipe有一个source通道和一个sink通道.数据会被写到sink通道,从source通道读取. 举个例子: package com.soyoungboy.nio; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.Pipe; import org.junit.Test; public class TestPipe { @Tes