javanio简单例子

⑴ 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 //当有异常发生时 继续进行循环操作

}

/**

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

*/

Set<SelectionKey> 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有个初步的了解了吧~~~

lishixin/Article/program/Java/hx/201311/27190

⑵ java中IO和NIO的区别和适用场景

以前在远标学过nio是new io的简称，从jdk1.4就被引入了，可以说不是什么新东西了。nio的主回要作用就是用来解答决速度差异的。举个例子：计算机处理的速度，和用户按键盘的速度。这两者的速度相差悬殊。如果按照经典的方法：一个用户设定一个线程，专门等待用户的输入，无形中就造成了严重的资源浪费：每一个线程都需要珍贵的cpu时间片，由于速度差异造成了在这个交互线程中的cpu都用来等待。 在以前的 Java IO 中，都是阻塞式 IO，NIO 引入了非阻塞式 IO。

⑶ java nio网上的例子都是死循环，CUP 100%，谁给我个真正能用的例子

看什抄么孙卫琴啊，都是垃圾，你好好看看安装好的JDK中的demo程序，那才是精品，其中有一个文件夹，全是nio的例子，保证运行，而且nio也不用非要用什么socket好吧，读文件也能用哈，只要是IO的流都可以

⑷ java.nio的描述

定义作为数据容器的缓冲区，并提供其他 NIO 包的概述。
NIO API 的集中抽象为：
缓冲区，它们是数据容器；
字符集及其相关解码器 和编码器，
它们在字节和 Unicode字符之间进行转换；
各种类型的通道，它们表示到能够执行 IO 操作的
实体的连接；以及选择器 和选择键，它们与
可桥升简选择信道 一起定义了多路的、无阻塞的
I/O 设施。
java.nio 包定义了缓冲区类，这些类用于所有 NIO API。java.nio.charset包中定义了字符集API，java.nio.channels包中定义了信道和选择器 API。每个子包都具有自己的服务提供程序接口(SPI) 子包，SPI 子包的内容可用于扩展平台的默认实现或构造替代实现。
缓冲敏裤区
描述
Buffer 位置，界限和容量；
清除，反转，重笑模绕和标记/重置
ByteBuffer Get/put，压缩，查看；分配，包装
MappedByteBuffer 映射到文件的字节缓冲区
CharBuffer Get/put，压缩；分配，包装
DoubleBuffer ' '
FloatBuffer ' '
IntBuffer ' '
LongBuffer ' '
ShortBuffer ' '
ByteOrder 字节顺序的类型安全的枚举

⑸ 什么是Java NIO，它的工作原理是什么

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

⑹ 求java nio网络编程的小例子，要求客户端一直与服务器保持连接

import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.*;
import java.io.*;

public class chatClient extends Frame {

/**
* @param args
*/
TextField tfTxT=new TextField();
TextArea taContent=new TextArea();
Socket s=null;
DataOutputStream dos=null;
DataInputStream dis=null;
private boolean bConnected =false;

public static void main(String[] args) {
new chatClient().lunachFrame();
}

private class RecvThread implements Runnable{

public void run() {
try{
while(bConnected){
String str=dis.readUTF();
taContent.setText(taContent.getText()+str+'\n');
}
}catch(IOException e){
e.printStackTrace();
}
}

}

public void lunachFrame(){
this.setLocation(400, 300);
this.setSize(300,300);
//this.setLayout(new FlowLayout());
this.add(tfTxT,"South");
this.add(taContent,"North");
pack();
tfTxT.addActionListener(new TFListener());
this.addWindowListener(new WindowClose());
this.setVisible(true);
connect();
new Thread(new RecvThread()).start();
}

public void connect(){
try {
s= new Socket("127.0.0.1",8888);
dos =new DataOutputStream(s.getOutputStream());
dis =new DataInputStream(s.getInputStream());
System.out.println("connected!");
bConnected=true;
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

public void disconnect(){
try {
dos.close();
s.close();
} catch (Exception e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}

class WindowClose extends WindowAdapter{

@Override
public void windowClosing(WindowEvent e) {
// TODO 自动生成方法存根
System.exit(0);
disconnect();
}

}

private class TFListener implements ActionListener{

public void actionPerformed(ActionEvent e) {
String str=tfTxT.getText().trim();//trim去掉两边空格
//taContent.setText(str);
tfTxT.setText("");
try {
dos.writeUTF(str);
dos.flush();
//dos.close();

} catch (IOException e1) {
e1.printStackTrace();

}
}
}
}

======================================
import java.io.IOException;
import java.net.*;
import java.io.*;
import java.util.*;

public class ChatServer {
List<Client> clients=new ArrayList<Client>();
Client c=null;

public static void main(String[] args){
new ChatServer().start();
}

public void start(){
boolean started=false;
ServerSocket ss=null;
DataInputStream dis=null;
try{
ss=new ServerSocket(8888);
started =true;
}catch(Exception e)
{
e.printStackTrace();
}
try{
while(started){
Socket s=ss.accept();
c=new Client(s);//启动线程,实行run()方法
System.out.println("a client connected!");
new Thread(c).start();//启动start方法,循环.start是Thread中的方法与这上面的start无关
clients.add(c);
//dis.close();
}
} catch (Exception e) {

//e.printStackTrace();
}
finally{
try {
ss.close();
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
}

class Client implements Runnable{

private Socket s;
private DataInputStream dis =null;
private boolean bConnected =false;
private DataOutputStream dos=null;

public Client(Socket s){
this.s=s;
try {
dis=new DataInputStream(s.getInputStream());
dos =new DataOutputStream(s.getOutputStream());
bConnected =true;
} catch (IOException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}

public void send(String str)throws Exception{
dos.writeUTF(str);

}

public void run() {
try{
while(bConnected){
String str = dis.readUTF();
System.out.println(str);
for(int i=0;i<clients.size();i++){
c=clients.get(i);
c.send(str);
}
/*for(Iterator<Client> it=clients.iterator();it.hasNext();){
Client c=it.next();
c.send(str);
}*/
}
}catch(SocketException e){
clients.remove(this);
System.out.println("客户下线了");
}
catch(EOFException e){
System.out.println("Client closed");
}
catch (Exception e){

//e.printStackTrace();
}
finally{
try {
if(dis !=null) dis.close();
if(dos !=null) dos.close();
if(s!=null) s.close();
} catch (Exception e1) {
// TODO 自动生成 catch 块
//e1.printStackTrace();
}
}
}
}

}

第一个是客户端,
第二个是server端

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

nio引入了buffer、channel、selector等概念。
通道相当于之前的I/O流。
“通道”太抽象了。java解释不清的东西只能看它底层是怎么解释的——操作系统的I/O控制，通道控制方式？
I/O设备：CPU——通道——设备控制器——I/O设备
（通道和设备控制器的关系是多对多，设备控制器和I/O设备的关系也是多对多。）
I/O过程，参考察握http://www.nbrkb.net/lwt/jsjsj/asm/INTR&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(); // 返回此选择器的已选择键集。 Set<SelectionKey> selectionKeys = selector.selectedKeys(); Iterator<SelectionKey> 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); // 分配缓冲区大小内存 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(); 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(count>0){ 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的效率会被拉下来。。。

⑻ Java NIO和IO的区别

JavaNIO和IO之间的主要差别，我会更详细地描述表中每部分的差异。
IONIO
面向流面向缓冲
阻塞IO非阻塞IO
无选择器
面向流与面向缓冲
JavaNIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。JavaIO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。JavaNIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。
阻塞与非阻塞IO
JavaIO的各种流是阻塞的。这意味着，当一个线程调用read()或write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。JavaNIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可运枣用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。
选择器（Selectors）
JavaNIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选兄和择机制，使得一个单独的线程很容易来管理多个通道。
NIO和IO如何影响应用程序的设计
无论您选择IO或NIO工具箱，可能会影响您应用程序设计的以下几个方面：
1.对NIO或IO类的API调用。
2.数据处理。
3.用来处理数据的线程数。
API调用
当然，使用NIO的API调用时看起来与羡悄盯使用IO时有所不同，但这并不意外，因为并不是仅从一个InputStream逐字节读取，而是数据必须先读入缓冲区再处理。
数据处理
使用纯粹的NIO设计相较IO设计，数据处理也受到影响。
在IO设计中，我们从InputStream或Reader逐字节读取数据。假设你正在处理一基于行的文本数据流，例如：
Name:Anna
Age:25
Email:[email protected]
Phone:1234567890
该文本行的流可以这样处理：
BufferedReaderreader=newBufferedReader(newInputStreamReader(input));

StringnameLine=reader.readLine();
StringageLine=reader.readLine();
StringemailLine=reader.readLine();
StringphoneLine=reader.readLine();
请注意处理状态由程序执行多久决定。换句话说，一旦reader.readLine()方法返回，你就知道肯定文本行就已读完，readline()阻塞直到整行读完，这就是原因。你也知道此行包含名称；同样，第二个readline()调用返回的时候，你知道这行包含年龄等。正如你可以看到，该处理程序仅在有新数据读入时运行，并知道每步的数据是什么。一旦正在运行的线程已处理过读入的某些数据，该线程不会再回退数据（大多如此）。下图也说明了这条原则：
（JavaIO:从一个阻塞的流中读数据）而一个NIO的实现会有所不同，下面是一个简单的例子：
ByteBufferbuffer=ByteBuffer.allocate(48);

intbytesRead=inChannel.read(buffer);
注意第二行，从通道读取字节到ByteBuffer。当这个方法调用返回时，你不知道你所需的所有数据是否在缓冲区内。你所知道的是，该缓冲区包含一些字节，这使得处理有点困难。
假设第一次read(buffer)调用后，读入缓冲区的数据只有半行，例如，“Name:An”，你能处理数据吗？显然不能，需要等待，直到整行数据读入缓存，在此之前，对数据的任何处理毫无意义。
所以，你怎么知道是否该缓冲区包含足够的数据可以处理呢？好了，你不知道。发现的方法只能查看缓冲区中的数据。其结果是，在你知道所有数据都在缓冲区里之前，你必须检查几次缓冲区的数据。这不仅效率低下，而且可以使程序设计方案杂乱不堪。例如：
ByteBufferbuffer=ByteBuffer.allocate(48);

intbytesRead=inChannel.read(buffer);

while(!bufferFull(bytesRead)){

bytesRead=inChannel.read(buffer);

}
bufferFull()方法必须跟踪有多少数据读入缓冲区，并返回真或假，这取决于缓冲区是否已满。换句话说，如果缓冲区准备好被处理，那么表示缓冲区满了。
bufferFull()方法扫描缓冲区，但必须保持在bufferFull（）方法被调用之前状态相同。如果没有，下一个读入缓冲区的数据可能无法读到正确的位置。这是不可能的，但却是需要注意的又一问题。
如果缓冲区已满，它可以被处理。如果它不满，并且在你的实际案例中有意义，你或许能处理其中的部分数据。但是许多情况下并非如此。下图展示了“缓冲区数据循环就绪”：
3)用来处理数据的线程数
NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。
如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。一个线程多个连接的设计方案如
JavaNIO:单线程管理多个连接
如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。下图说明了一个典型的IO服务器设计：

JavaIO:一个典型的IO服务器设计-一个连接通过一个线程处理

⑼ 介绍一下Java NIO，NIO读取文件都有哪些方法

NIO也就是New I/O,是一组扩展Java IO操作的API集， 于Java 1.4起被引入，Java 7中NIO又提供了一些新的文件系统API，叫.
NIO2提供两种主要的文件读取方法：
使用buffer和channel类
使用Path 和 File 类
NIO读取文件有以下三种方式：
1. 旧的NIO方式，使用BufferedReader
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class WithoutNIOExample
{
public static void main(String[] args)
{
BufferedReader br = null;
String sCurrentLine = null;
try
{
br = new BufferedReader(
new FileReader("test.txt"));
while ((sCurrentLine = br.readLine()) != null)
{
System.out.println(sCurrentLine);
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
if (br != null)
br.close();
} catch (IOException ex)
{
ex.printStackTrace();
}
}
}
}
2. 使用buffer读取小文件
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithFileSizeBuffer
{
public static void main(String args[])
{
try
{
RandomAccessFile aFile = new RandomAccessFile(
"test.txt","r");
FileChannel inChannel = aFile.getChannel();
long fileSize = inChannel.size();
ByteBuffer buffer = ByteBuffer.allocate((int) fileSize);
inChannel.read(buffer);
buffer.rewind();
buffer.flip();
for (int i = 0; i < fileSize; i++)
{
System.out.print((char) buffer.get());
}
inChannel.close();
aFile.close();
}
catch (IOException exc)
{
System.out.println(exc);
System.exit(1);
}
}
}
3. 分块读取大文件
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithFixedSizeBuffer
{
public static void main(String[] args) throws IOException
{
RandomAccessFile aFile = new RandomAccessFile
("test.txt", "r");
FileChannel inChannel = aFile.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while(inChannel.read(buffer) > 0)
{
buffer.flip();
for (int i = 0; i < buffer.limit(); i++)
{
System.out.print((char) buffer.get());
}
buffer.clear(); // do something with the data and clear/compact it.
}
inChannel.close();
aFile.close();
}
}
4. 使用MappedByteBuffer读取文件
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
public class ReadFileWithMappedByteBuffer
{
public static void main(String[] args) throws IOException
{
RandomAccessFile aFile = new RandomAccessFile
("test.txt", "r");
FileChannel inChannel = aFile.getChannel();
MappedByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());
buffer.load();?
for (int i = 0; i < buffer.limit(); i++)
{
System.out.print((char) buffer.get());
}
buffer.clear(); // do something with the data and clear/compact it.
inChannel.close();
aFile.close();
}
}

⑽ Java NIO与IO的区别和比较

J2SE1.4以上版本中发布了全新的I/O类库。本文将通过一些实例来简单介绍NIO库提供的一些新特性：非阻塞I/O，字符转换，缓冲以及通道。
一. 介绍NIO
NIO包（java.nio.*）引入了四个关键的抽象数据类型，它们共同解决传统的I/O类中的一些问题。
1． Buffer：它是包含数据且用于读写的线形表结构。其中还提供了一个特殊类用于内存映射文件的I/O操作。
2． Charset：它提供Unicode字符串影射到字节序列以及逆影射的操作。
3． Channels：包含socket，file和pipe三种管道，它实际上是双向交流的通道。
4． Selector：它将多元异步I/O操作集中到一个或多个线程中（它可以被看成是Unix中select（）函数或Win32中WaitForSingleEvent（）函数的面向对象版本）。
二. 回顾传统
在介绍NIO之前，有必要了解传统的I/O操作的方式。以网络应用为例，传统方式需要监听一个ServerSocket，接受请求的连接为其提供服务（服务通常包括了处理请求并发送响应）图一是服务器的生命周期图，其中标有粗黑线条的部分表明会发生I/O阻塞。

图一

可以分析创建服务器的每个具体步骤。首先创建ServerSocket
ServerSocket server=new ServerSocket（10000）；
然后接受新的连接请求
Socket newConnection=server.accept（）；
对于accept方法的调用将造成阻塞，直到ServerSocket接受到一个连接请求为止。一旦连接请求被接受，服务器可以读客户socket中的请求。
InputStream in = newConnection.getInputStream();
InputStreamReader reader = new InputStreamReader(in);
BufferedReader buffer = new BufferedReader(reader);
Request request = new Request();
while(!request.isComplete()) {
String line = buffer.readLine();
request.addLine(line);
}
这样的操作有两个问题，首先BufferedReader类的readLine（）方法在其缓冲区未满时会造成线程阻塞，只有一定数据填满了缓冲区或者客户关闭了套接字，方法才会返回。其次，它回产生大量的垃圾，BufferedReader创建了缓冲区来从客户套接字读入数据，但是同样创建了一些字符串存储这些数据。虽然BufferedReader内部提供了StringBuffer处理这一问题，但是所有的String很快变成了垃圾需要回收。
同样的问题在发送响应代码中也存在
Response response = request.generateResponse();
OutputStream out = newConnection.getOutputStream();
InputStream in = response.getInputStream()；
int ch；
while(-1 != (ch = in.read())) {
out.write(ch);
}
newConnection.close();
类似的，读写操作被阻塞而且向流中一次写入一个字符会造成效率低下，所以应该使用缓冲区，但是一旦使用缓冲，流又会产生更多的垃圾。
传统的解决方法
通常在Java中处理阻塞I/O要用到线程（大量的线程）。一般是实现一个线程池用来处理请求，如图二

图二
线程使得服务器可以处理多个连接，但是它们也同样引发了许多问题。每个线程拥有自己的栈空间并且占用一些CPU时间，耗费很大，而且很多时间是浪费在阻塞的I/O操作上，没有有效的利用CPU。
三. 新I/O
1． Buffer
传统的I/O不断的浪费对象资源（通常是String）。新I/O通过使用Buffer读写数据避免了资源浪费。Buffer对象是线性的，有序的数据集合，它根据其类别只包含唯一的数据类型。
java.nio.Buffer 类描述
java.nio.ByteBuffer 包含字节类型。 可以从ReadableByteChannel中读在 WritableByteChannel中写
java.nio.MappedByteBuffer 包含字节类型，直接在内存某一区域映射
java.nio.CharBuffer 包含字符类型，不能写入通道
java.nio.DoubleBuffer 包含double类型，不能写入通道
java.nio.FloatBuffer 包含float类型
java.nio.IntBuffer 包含int类型
java.nio.LongBuffer 包含long类型
java.nio.ShortBuffer 包含short类型
可以通过调用allocate(int capacity)方法或者allocateDirect(int capacity)方法分配一个Buffer。特别的，你可以创建MappedBytesBuffer通过调用FileChannel.map(int mode,long position,int size)。直接（direct）buffer在内存中分配一段连续的块并使用本地访问方法读写数据。非直接(nondirect)buffer通过使用Java中的数组访问代码读写数据。有时候必须使用非直接缓冲例如使用任何的wrap方法（如ByteBuffer.wrap(byte[])）在Java数组基础上创建buffer。
2． 字符编码
向ByteBuffer中存放数据涉及到两个问题：字节的顺序和字符转换。ByteBuffer内部通过ByteOrder类处理了字节顺序问题，但是并没有处理字符转换。事实上，ByteBuffer没有提供方法读写String。
Java.nio.charset.Charset处理了字符转换问题。它通过构造CharsetEncoder和CharsetDecoder将字符序列转换成字节和逆转换。
3． 通道(Channel)
你可能注意到现有的java.io类中没有一个能够读写Buffer类型，所以NIO中提供了Channel类来读写Buffer。通道可以认为是一种连接，可以是到特定设备，程序或者是网络的连接。通道的类等级结构图如下

图三
图中ReadableByteChannel和WritableByteChannel分别用于读写。
GatheringByteChannel可以从使用一次将多个Buffer中的数据写入通道，相反的，ScatteringByteChannel则可以一次将数据从通道读入多个Buffer中。你还可以设置通道使其为阻塞或非阻塞I/O操作服务。
为了使通道能够同传统I/O类相容，Channel类提供了静态方法创建Stream或Reader
4． Selector
在过去的阻塞I/O中，我们一般知道什么时候可以向stream中读或写，因为方法调用直到stream准备好时返回。但是使用非阻塞通道，我们需要一些方法来知道什么时候通道准备好了。在NIO包中，设计Selector就是为了这个目的。SelectableChannel可以注册特定的事件，而不是在事件发生时通知应用，通道跟踪事件。然后，当应用调用Selector上的任意一个selection方法时，它查看注册了的通道看是否有任何感兴趣的事件发生。图四是selector和两个已注册的通道的例子

图四
并不是所有的通道都支持所有的操作。SelectionKey类定义了所有可能的操作位，将要用两次。首先，当应用调用SelectableChannel.register(Selector sel,int op)方法注册通道时，它将所需操作作为第二个参数传递到方法中。然后，一旦SelectionKey被选中了，SelectionKey的readyOps()方法返回所有通道支持操作的数位的和。SelectableChannel的validOps方法返回每个通道允许的操作。注册通道不支持的操作将引发IllegalArgumentException异常。下表列出了SelectableChannel子类所支持的操作。

ServerSocketChannel OP_ACCEPT
SocketChannel OP_CONNECT, OP_READ, OP_WRITE
DatagramChannel OP_READ, OP_WRITE
Pipe.SourceChannel OP_READ
Pipe.SinkChannel OP_WRITE
四. 举例说明
1． 简单网页内容下载
这个例子非常简单，类SocketChannelReader使用SocketChannel来下载特定网页的HTML内容。
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.net.InetSocketAddress;
import java.io.IOException;
public class SocketChannelReader{

private Charset charset=Charset.forName("UTF-8");//创建UTF-8字符集
private SocketChannel channel;
public void getHTMLContent(){
try{
connect();
sendRequest();
readResponse();
}catch(IOException e){
System.err.println(e.toString());
}finally{
if(channel!=null){
try{
channel.close();
}catch(IOException e){}
}
}
}
private void connect()throws IOException{//连接到CSDN
InetSocketAddress socketAddress=
new InetSocketAddress("http://www.csdn.net",80/);
channel=SocketChannel.open(socketAddress);
//使用工厂方法open创建一个channel并将它连接到指定地址上
//相当与SocketChannel.open().connect(socketAddress);调用
}
private void sendRequest()throws IOException{
channel.write(charset.encode("GET "
+"/document"
+"\r\n\r\n"));//发送GET请求到CSDN的文档中心
//使用channel.write方法，它需要CharByte类型的参数，使用
//Charset.encode(String)方法转换字符串。
}
private void readResponse()throws IOException{//读取应答
ByteBuffer buffer=ByteBuffer.allocate(1024);//创建1024字节的缓冲
while(channel.read(buffer)!=-1){
buffer.flip();//flip方法在读缓冲区字节操作之前调用。
System.out.println(charset.decode(buffer));
//使用Charset.decode方法将字节转换为字符串
buffer.clear();//清空缓冲
}
}
public static void main(String [] args){
new SocketChannelReader().getHTMLContent();
}
2． 简单的加法服务器和客户机
服务器代码
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumServer.java
*
*
* Created: Thu Nov 06 11:41:52 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumServer {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer=_buffer.asIntBuffer();
private SocketChannel _clientChannel=null;
private ServerSocketChannel _serverChannel=null;
public void start(){
try{
openChannel();
waitForConnection();
}catch(IOException e){
System.err.println(e.toString());
}
}
private void openChannel()throws IOException{
_serverChannel=ServerSocketChannel.open();
_serverChannel.socket().bind(new InetSocketAddress(10000));
System.out.println("服务器通道已经打开");
}
private void waitForConnection()throws IOException{
while(true){
_clientChannel=_serverChannel.accept();
if(_clientChannel!=null){
System.out.println("新的连接加入");
processRequest();
_clientChannel.close();
}
}
}
private void processRequest()throws IOException{
_buffer.clear();
_clientChannel.read(_buffer);
int result=_intBuffer.get(0)+_intBuffer.get(1);
_buffer.flip();
_buffer.clear();
_intBuffer.put(0,result);
_clientChannel.write(_buffer);
}
public static void main(String [] args){
new SumServer().start();
}
} // SumServer
客户代码
package examples.nio;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.SocketChannel;
import java.net.InetSocketAddress;
import java.io.IOException;
/**
* SumClient.java
*
*
* Created: Thu Nov 06 11:26:06 2003
*
* @author starchu1981
* @version 1.0
*/
public class SumClient {
private ByteBuffer _buffer=ByteBuffer.allocate(8);
private IntBuffer _intBuffer;
private SocketChannel _channel;
public SumClient() {
_intBuffer=_buffer.asIntBuffer();
} // SumClient constructor

public int getSum(int first,int second){
int result=0;
try{
_channel=connect();
sendSumRequest(first,second);
result=receiveResponse();
}catch(IOException e){System.err.println(e.toString());
}finally{
if(_channel!=null){
try{
_channel.close();
}catch(IOException e){}
}
}
return result;
}
private SocketChannel connect()throws IOException{
InetSocketAddress socketAddress=
new InetSocketAddress("localhost",10000);
return SocketChannel.open(socketAddress);
}

private void sendSumRequest(int first,int second)throws IOException{
_buffer.clear();
_intBuffer.put(0,first);
_intBuffer.put(1,second);
_channel.write(_buffer);
System.out.println("发送加法请求 "+first+"+"+second);
}

private int receiveResponse()throws IOException{
_buffer.clear();
_channel.read(_buffer);
return _intBuffer.get(0);
}
public static void main(String [] args){
SumClient sumClient=new SumClient();
System.out.println("加法结果为 :"+sumClient.getSum(100,324));
}
} // SumClient
3． 非阻塞的加法服务器
首先在openChannel方法中加入语句
_serverChannel.configureBlocking(false);//设置成为非阻塞模式
重写WaitForConnection方法的代码如下，使用非阻塞方式
private void waitForConnection()throws IOException{
Selector acceptSelector = SelectorProvider.provider().openSelector();
/*在服务器套接字上注册selector并设置为接受accept方法的通知。
这就告诉Selector，套接字想要在accept操作发生时被放在ready表
上，因此，允许多元非阻塞I/O发生。*/
SelectionKey acceptKey = ssc.register(acceptSelector,
SelectionKey.OP_ACCEPT);
int keysAdded = 0;