nioJAVA代码 nio代码示例

什么是NIO框架？

Java NIO框架MINA用netty性能和链接数、并发等压力测试参数好于mina。\x0d\x0a\x0d\x0a特点：\x0d\x0a1。NIO弥补了原来的I/O的不足，它再标准java代码中提供了高速和面向块的I/O\x0d\x0a原力的I/O库与NIO最重要的区别是数据打包和传输方式的不同，原来的I/O以流的方式处理数据，而NIO以块的方式处理数据；\x0d\x0a\x0d\x0a2.NIO以通道channel和缓冲区Buffer为基础来实现面向块的IO数据处理，MINA是开源的。\x0d\x0a\x0d\x0aJavaNIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。\x0d\x0a\x0d\x0aJava NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个线程死等，从外界看，实现了流畅的I/O读写，不堵塞了。\x0d\x0a\x0d\x0aJava NIO出现不只是一个技术性能的提高，会发现网络上到处在介绍它，因为它具有里程碑意义，从JDK1.4开始，Java开始提高性能相关的功能，从而使得Java在底层或者并行分布式计算等操作上已经可以和C或Perl等语言并驾齐驱。\x0d\x0a\x0d\x0a如果至今还是在怀疑Java的性能，说明思想和观念已经完全落伍了，Java一两年就应该用新的名词来定义。从JDK1.5开始又要提供关于线程、并发等新性能的支持，Java应用在游戏等适时领域方面的机会已经成熟，Java在稳定自己中间件地位后，开始蚕食传统C的领域。\x0d\x0a\x0d\x0a原理：\x0d\x0aNIO 有一个主要的类Selector,这个类似一个观察者，只要我们把需要探知socketchannel告诉Selector,我们接着做别的事情，当有事件发生时，他会通知我们，传回一组SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的socketchannel,然后，我们从这个Channel中读取数据，放心，包准能够读到，接着我们可以处理这些数据。Selector内部原理实际是在做一个对所注册的channel的轮询访问，不断的轮询(目前就这一个算法)，一旦轮询到一个channel有所注册的事情发生。比如数据来了，他就会站起来报告，交出一把钥匙，让我们通过这把钥匙来读取这个channel的内容。在使用上，也在分两个方向，一个是线程处理，一个是用非线程，后者比较简单。

十载的日照网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。营销型网站的优势是能够根据用户设备显示端的尺寸不同，自动调整日照建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联建站从事“日照网站设计”,“日照网站推广”以来，每个客户项目都认真落实执行。

java nio 开发实例

首先了解下所谓的java nio是个什么东西！

传统的并发型服务器设计是利用阻塞型网络I/O 以多线程的模式来实现的 然而由

于系统常常在进行网络读写时处于阻塞状态 会大大影响系统的性能 自Java 开始引入

了NIO(新I/O) API 通过使用非阻塞型I/O 实现流畅的网络读写操作 为开发高性能并发

型服务器程序提供了一个很好的解决方案 这就是java nio

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

Java 平台传统的I/O 系统都是基于Byte（字节）和Stream（数据流）的 相应的I/O 操

作都是阻塞型的 所以服务器程序也采用阻塞型I/O 进行数据的读 写操作 本文以TCP

长连接模式来讨论并发型服务器的相关设计 为了实现服务器程序的并发性要求 系统由一

个单独的主线程来监听用户发起的连接请求 一直处于阻塞状态 当有用户连接请求到来时

程序都会启一个新的线程来统一处理用户数据的读 写操作

这种模式的优点是简单 实用 易管理 然而缺点也是显而易见的 由于是为每一个客

户端分配一个线程来处理输入 输出数据 其线程与客户机的比例近似为 随着线程

数量的不断增加 服务器启动了大量的并发线程 会大大加大系统对线程的管理开销 这将

成为吞吐量瓶颈的主要原因 其次由于底层的I/O 操作采用的同步模式 I/O 操作的阻塞管

理粒度是以服务于请求的线程为单位的 有可能大量的线程会闲置 处于盲等状态 造成I/O

资源利用率不高 影响整个系统的性能

对于并发型服务器 系统用在阻塞型I/O 等待和线程间切换的时间远远多于CPU 在内

存中处理数据的时间 因此传统的阻塞型I/O 已经成为制约系统性能的瓶颈 Java 版本

后推出的NIO 工具包 提供了非阻塞型I/O 的异步输入输出机制 为提高系统的性能提供

了可实现的基础机制

NIO 包及工作原理

针对传统I/O 工作模式的不足 NIO 工具包提出了基于Buffer（缓冲区） Channel（通

道） Selector（选择器）的新模式 Selector（选择器） 可选择的Channel（通道）和

SelectionKey（选择键）配合起来使用 可以实现并发的非阻塞型I/O 能力

NIO 工具包的成员

Buffer（缓冲器）

Buffer 类是一个抽象类 它有 个子类分别对应于七种基本的数据类型 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（选择器）和SelectionKey（选择键）

各类 Buffer 是数据的容器对象 各类Channel 实现在各类Buffer 与各类I/O 服务间传输

数据 Selector 是实现并发型非阻塞I/O 的核心 各种可选择的通道将其感兴趣的事件注册

到Selector 对象上 Selector 在一个循环中不断轮循监视这各些注册在其上的Socket 通道

SelectionKey 类则封装了SelectableChannel 对象在Selector 中的注册信息 当Selector 监测

到在某个注册的SelectableChannel 上发生了感兴趣的事件时 自动激活产生一个SelectionKey

对象 在这个对象中记录了哪一个SelectableChannel 上发生了哪种事件 通过对被激活的

SelectionKey 的分析 外界可以知道每个SelectableChannel 发生的具体事件类型 进行相应的

处理

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 * //引入Java io包

import * //引入包

import java nio channels * //引入Java nio channels包

import java util * //引入Java util包

public class TestServer implements Runnable

{

/**

* 服务器Channel对象 负责接受用户连接

*/

private ServerSocketChannel server

/**

* Selector对象 负责监控所有的连接到服务器的网络事件的发生

*/

private Selector selector

/**

* 总的活动连接数

*/

private int activeSockets

/**

* 服务器Channel绑定的端口号

*/

private int port

/**

*

* 构造函数

*/

public TestServer()throws IOException

{

activeSockets=

port= //初始化服务器Channel绑定的端口号为

selector= Selector open() //初始化Selector对象

server=ServerSocketChannel open() //初始化服务器Channel对象

ServerSocket socket=server socket() //获取服务器Channel对应的//ServerSocket对象

socket bind(new InetSocketAddress(port)) //把Socket绑定到监听端口 上

nfigureBlocking(false) //将服务器Channel设置为非阻塞模式

server register(selector SelectionKey OP_ACCEPT) //将服务器Channel注册到

Selector对象 并指出服务器Channel所感兴趣的事件为可接受请求操作

}

public void run()

{

while(true)

{

try

{

/**

*应用Select机制轮循是否有用户感兴趣的新的网络事件发生 当没有

* 新的网络事件发生时 此方法会阻塞 直到有新的网络事件发生为止

*/

selector select()

}

catch(IOException e)

{

continue //当有异常发生时 继续进行循环操作

}

/**

* 得到活动的网络连接选择键的集合

*/

SetSelectionKey keys=selector selectedKeys()

activeSockets=keys size() //获取活动连接的数目

if(activeSockets== )

{

continue //如果连接数为 则继续进行循环操作

}

/**

/**

* 应用For—Each循环遍历整个选择键集合

*/

for(SelectionKey key :keys)

{

/**

* 如果关键字状态是为可接受 则接受连接 注册通道 以接受更多的*

事件 进行相关的服务器程序处理

*/

if(key isAcceptable())

{

doServerSocketEvent(key)

continue

}

/**

* 如果关键字状态为可读 则说明Channel是一个客户端的连接通道

* 进行相应的读取客户端数据的操作

*/

if(key isReadable())

{

doClientReadEvent(key)

continue

}

/**

* 如果关键字状态为可写 则也说明Channel是一个客户端的连接通道

* 进行相应的向客户端写数据的操作

*/

if(key isWritable())

{

doClinetWriteEvent(key)

continue

}

}

}

}

/**

* 处理服务器事件操作

* @param key 服务器选择键对象

*/

private void doServerSocketEvent(SelectionKey key)

{

SocketChannel client=null

try

{

ServerSocketChannel server=(ServerSocketChannel)key channel()

client=server accept()

if(client==null)

{

return

}

nfigureBlocking(false) //将客户端Channel设置为非阻塞型

/**

/**

* 将客户端Channel注册到Selector对象上 并且指出客户端Channel所感

* 兴趣的事件为可读和可写

*/

client register(selector SelectionKey OP_READ|SelectionKey OP_READ)

}catch(IOException e)

{

try

{

client close()

}catch(IOException e ){}

}

}

/**

* 进行向客户端写数据操作

* @param key 客户端选择键对象

*/

private void doClinetWriteEvent(SelectionKey key)

{

代码实现略

}

/**

* 进行读取客户短数据操作

* @param key 客户端选择键对象

*/

private void doClientReadEvent(SelectionKey key)

{

代码实现略

}

}

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

向Selector对象注册感兴趣的事件 从Selector中获取所感兴趣的事件 根据不同的事件进

行相应的处理

结语

通过使用NIO 工具包进行并发型服务器程序设计 一个或者很少几个Socket 线程就可

以处理成千上万个活动的Socket 连接 大大降低了服务器端程序的开销 同时网络I/O 采取

非阻塞模式 线程不再在读或写时阻塞 操作系统可以更流畅的读写数据并可以更有效地向

CPU 传递数据进行处理 以便更有效地提高系统的性能

看到这里相信你看了不止 分钟了吧   我说 分钟其实就是想让大家能够轻松的读下去（鸡蛋 ）

好了 到这里大家应该对java nio有个初步的了解了吧~~~

lishixinzhi/Article/program/Java/hx/201311/27190

sun.nio包是什么，是java代码么

nio是针对原java io所开发的一套新的io api接口。 Java NIO（New IO）是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。

Java NIO怎么理解通道和非阻塞

nio引入了buffer、channel、selector等概念。

通道相当于之前的I/O流。

“通道”太抽象了。java解释不清的东西只能看它底层是怎么解释的——操作系统的I/O控制，通道控制方式？

I/O设备：CPU——通道——设备控制器——I/O设备

（通道和设备控制器的关系是多对多，设备控制器和I/O设备的关系也是多对多。）

I/O过程，参考;DMA.htm：

1.CPU在执行用户程序时遇到I/O请求，根据用户的I/O请求生成通道程序（也可以是事先编好的）。放到内存中，并把该通道程序首地址放入CAW中。

2.CPU执行“启动I/O”指令，启动通道工作。

3.通道接收“启动I/O”指令信号，从CAW（记录下一条通道指令存放的地址）中取出通道程序首地址，并根据此地址取出通道程序的第一条指令，放入CCW（记录正在执行的通道指令）中；同时向CPU发回答信号，通知“启动I/O”指令完成完毕，CPU可继续执行。

4.与此同时，通道开始执行通道程序，进行物理I/O操作。当执行完一条指令后，如果还有下一条指令则继续执行；否则表示传输完成，同时自行停止，通知CPU转去处理通道结束事件，并从CCW中得到有关通道状态。

如此一来，主处理器只要发出一个I/O操作命令，剩下的工作完全由通道负责。I/O操作结束后，I/O通道会发出一个中断请求，表示相应操作已完成。

通道控制方式是对数据块进行处理的，并非字节。

通道控制方式就是异步I/O

I/O分两段：1.数据从I/O设备到内核缓冲区。2.数据从内核缓冲区到应用缓冲区

I/O类型：

1.异步I/O不会产生阻塞，程序不会等待I/O完成，继续执行代码，等I/O完成了再执行一个什么回调函数，代码执行效率高。很容易联想到ajax。这个一般用于I/O操作不影响之后的代码执行。

2.阻塞I/O，程序发起I/O操作后，进程阻塞，CPU转而执行其他进程，I/O的两个步骤完成后，向CPU发送中断信号，进程就绪，等待执行。

3.非阻塞I/O并非都不阻塞，其实是第一步不阻塞，第二部阻塞。程序发起I/O操作后，进程一直检查第一步是否完成，CPU一直在循环询问，完成后，进程阻塞直到完成第二步。明白了！这个是“站着茅坑不拉屎”，CPU利用率最低的。逻辑和操作系统的程序直接控制方式一样。

阻塞不阻塞描述的是发生I/O时当前线程的状态。

以上是操作系统的I/O，那么java的nio又是怎样的呢？

个人觉得是模仿了通道控制方式。

先看看nio的示例代码：

服务端TestReadServer.java

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 TestReadServer { /*标识数字*/ private int flag = 0; /*缓冲区大小*/ private int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); private Selector selector; public TestReadServer(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----"+port+":"); } // 监听 private void listen() throws IOException { while (true) { // 选择一组键，并且相应的通道已经打开 selector.select(); // 返回此选择器的已选择键集。 SetSelectionKey selectionKeys = selector.selectedKeys(); IteratorSelectionKey iterator = selectionKeys.iterator(); 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()) { // 返回为之创建此键的通道。 server = (ServerSocketChannel) selectionKey.channel(); // 接受到此通道套接字的连接。 // 此方法返回的套接字通道（如果有）将处于阻塞模式。 client = server.accept(); // 配置为非阻塞 client.configureBlocking(false); // 注册到selector，等待连接 client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { // 返回为之创建此键的通道。 client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 System.out.println(System.currentTimeMillis()); count = client.read(receivebuffer); System.out.println(System.currentTimeMillis() + "~"+count); } } /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub int port = 1234; TestReadServer server = new TestReadServer(port); server.listen(); } }客户端TestReadClient.javaimport java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; 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 TestReadClient { /*标识数字*/ private static int flag = 0; /*缓冲区大小*/ private static int BLOCK = 1024*1024*10; /*接受数据缓冲区*/ private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK); /*发送数据缓冲区*/ private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK); /*服务器端地址*/ private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress( "localhost", 1234); 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); // 分配缓冲区大小内存 SetSelectionKey selectionKeys; IteratorSelectionKey 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(); BufferedInputStream br = new BufferedInputStream(new FileInputStream(new File("D:\BigData.zip"))); byte[] b = new byte[BLOCK]; br.read(b); sendbuffer.put(b); sendbuffer.flip(); System.out.println(System.currentTimeMillis()); client.write(sendbuffer); System.out.println(System.currentTimeMillis()); } client.register(selector, SelectionKey.OP_READ); } else if (selectionKey.isReadable()) { client = (SocketChannel) selectionKey.channel(); //将缓冲区清空以备下次读取 receivebuffer.clear(); //读取服务器发送来的数据到缓冲区中 count=client.read(receivebuffer); if(count0){ receiveText = new String( receivebuffer.array(),0,count); System.out.println("客户端接受服务器端数据--:"+receiveText); client.register(selector, SelectionKey.OP_WRITE); } } } selectionKeys.clear(); } } }例子是TestReadClient向TestReadServer发送一个本地文件。TestReadServer收到后每次打印读取到的字节数。

如何体现异步I/O？

看看TestReadClient中的：

if (selectionKey.isConnectable()) { System.out.println("client connect"); client = (SocketChannel) selectionKey.channel(); // 判断此通道上是否正在进行连接操作。 // 完成套接字通道的连接过程。 if (client.isConnectionPending()) { client.finishConnect();如果没有client.finishConnect();这句等待完成socket连接，可能会报异常：java.nio.channels.NotYetConnectedException

异步的才不会管你有没有连接成功，都会执行下面的代码。这里需要人为的干预。

如果要证明是java的nio单独使用非阻塞I/O，真没办法！！！阻塞非阻塞要查看进程。。。

不过还有种说法，叫异步非阻塞。上面那段，是用异步方式创建连接，进程当然没有被阻塞。使用了finishConnect()这是人为将程序中止，等待连接创建完成（是模仿阻塞将当前进程阻塞掉，还是模仿非阻塞不断轮询访问，不重要了反正是程序卡住没往下执行）。

所以，创建连接的过程用异步非阻塞I/O可以解释的通。那read/write的过程呢？

根据上面例子的打印结果，可以知道这个过程是同步的，没执行完是不会执行下面的代码的。至于底下是使用阻塞I/O还是非阻塞I/O，对于应用级程序来说不重要了。

阻塞还是非阻塞，对于正常的开发（创立连接，从连接中读写数据）并没有多少的提升，操作过程都类似。

那NIO凭什么成为高性能架构的基础，比起IO，性能优越在哪里，接着猜。。。

java nio有意模仿操作系统的通道控制方式，那他的底层是不是就是直接使用操作系统的通道？

通道中的数据是以块为单位的，之前的流是以字节为单位的，同样的数据流操作外设的次数较多。代码中channel都是针对ByteBuffer对象进行read/write的，而ByteBuffer又是ByteBuffer.allocate(BLOCK);这样创建的，是一个连续的块空间。

那ByteBuffer是不是也是模拟操作系统的缓存？

缓存在io也有，如BufferedInputStream。CPU和外设的速度差很多，缓存为了提高CPU使用率，等外设将数据读入缓存后，CPU再统一操作，不用外设读一次，CPU操作一次，CPU的效率会被拉下来。。。