Java NIO及其常用API
来源：互联网 发布：淘宝什么评论有福利 编辑：程序博客网 时间：2024/06/05 06:20
一、初识NIO
> 在 JDK 1. 4 中 新 加入 了 NIO( New Input/ Output) 类, 引入了一种基于通道和缓冲区的 I/O 方式，它可以使用 Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆的 DirectByteBuffer 对象作为这块内存的引用进行操作，避免了在 Java 堆和 Native 堆中来回复制数据。NIO 是一种同步非阻塞的 IO 模型。同步是指线程不断轮询 IO 事件是否就绪，非阻塞是指线程在等待 IO 的时候，可以同时做其他任务。同步的核心就是 Selector，Selector 代替了线程本身轮询 IO 事件，避免了阻塞同时减少了不必要的线程消耗；非阻塞的核心就是通道和缓冲区，当 IO 事件就绪时，可以通过写道缓冲区，保证 IO 的成功，而无需线程阻塞式地等待。 在NIO中有几个比较关键的概念：Buffer（缓冲区），Channel（通道），Selector（选择器）。Buffer（缓冲区）:
在Java NIO中负责数据的存取，缓冲区就是数组，用于存储不同类型的缓冲区。为什么说NIO是基于缓冲区的IO方式呢？因为，当一个链接建立完成后，IO的数据未必会马上到达，为了当数据到达时能够正确完成IO操作，在BIO（阻塞IO）中，等待IO的线程必须被阻塞，以全天候地执行IO操作。为了解决这种IO方式低效的问题，引入了缓冲区的概念，当数据到达时，可以预先被写入缓冲区，再由缓冲区交给线程，因此线程无需阻塞地等待IO。
Channel（通道）:
用于源节点与目标节点的连接，在java NIO 中负责缓冲区中的数据传输，Channel本身不存储数据，因此需要缓冲区配合进行传输，通道就相当于铁轨，缓冲区就相当于火车。
引用 Java NIO 中权威的说法：通道是 I/O 传输发生时通过的入口，而缓冲区是这些数 据传输的来源或目标。对于离开缓冲区的传输，您想传递出去的数据被置于一个缓冲区，被传送到通道。对于传回缓冲区的传输，一个通道将数据放置在您所提供的缓冲区中。
例如 有一个服务器通道 ServerSocketChannel serverChannel，一个客户端通道 SocketChannel clientChannel；服务器缓冲区：serverBuffer，客户端缓冲区：clientBuffer。当服务器想向客户端发送数据时，需要调用：clientChannel.write(serverBuffer)。当客户端要读时，调用 clientChannel.read(clientBuffer)当客户端想向服务器发送数据时，需要调用：serverChannel.write(clientBuffer)。当服务器要读时，调用 serverChannel.read(serverBuffer)Selector（选择器）:
通道和缓冲区的机制，使得线程无需阻塞地等待IO事件的就绪，但是总是要有人来监管这些IO事件。这个工作就交给了selector来完成，这就是所谓的同步。Selector允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪，这就是所说的轮询。一旦这个方法返回，线程就可以处理这些事件。
Selector中注册的感兴趣事件有：OP_ACCEPT：接收
OP_CONNECT ：连接
OP_READ ：读
OP_WRITE：写
二、Java NIO 常用API
1.Buffer
package com.jxhtyw;import java.nio.ByteBuffer;import org.junit.Test;/** *缓冲区(buffer):在java NIO中负责数据的存取，缓冲区就是数组，用于存储不同类型的缓冲区 *缓冲区类型： *ByteBuffer *CharBuffer *IntBuffer *ShortBuffer *LongBuffer *DoubleBuffer * * 核心方法:put()和get() * * 核心属性： * capacity:容量，表示缓冲区中最大数据的存储容量 * limit:界限，表示缓冲区中可以操作数据的大小（limit后数据不能进行读写） * position：位置，表示缓冲区中正在操作数据的位置 * * mark():标记 * reset():恢复到mark的位置 * * @author dxx * @version 2017-11-02 下午7:46:38 */public class NioBuffer { String str="helloworld"; @Test public void run(){ //1.分配一个指定大小的缓冲区 ByteBuffer bb=ByteBuffer.allocate(1024); System.out.println(bb.capacity()); System.out.println(bb.limit()); System.out.println(bb.position()); //2.存入数据 bb.put(str.getBytes()); System.out.println(bb.capacity()); System.out.println(bb.limit()); System.out.println(bb.position());//位置变为10 //3.切换读取数据模式 bb.flip(); System.out.println(bb.capacity());//缓冲区大小仍然为1024 System.out.println(bb.limit());//可读取数量为10个的字节 System.out.println(bb.position());//位置切换到0了，可以从0开始读取 //4.读取数据 byte[] by=new byte[bb.limit()]; bb.get(by);//获取到缓冲区可读取的所有数据（也就是10）,存放在by数组中 //System.out.println(by); System.out.println(new String(by,0,by.length)); System.out.println(bb.capacity()); System.out.println(bb.limit()); System.out.println(bb.position()); try { bb.get();//再读的话就越界了 } catch (Exception e) { e.printStackTrace(); } //5.rewind() ：可重复读数据 bb.rewind(); System.out.println(bb.capacity()); System.out.println(bb.limit()); System.out.println(bb.position());//位置变为0了，说明又可以读了 //6.clear()：清空缓冲区，但是缓冲区的数据依然存在，但是处于“被遗忘状态” bb.clear(); System.out.println(bb.capacity()); System.out.println(bb.limit());//指针全部回到最原始状态，不知道有多少数据 System.out.println(bb.position()); System.out.println((char)bb.get()); } @Test public void run2(){ ByteBuffer bb=ByteBuffer.allocate(1024); bb.put(str.getBytes()); bb.flip(); byte[] by=new byte[bb.limit()]; bb.get(by,0,2); System.out.println(new String(by,0,2)); System.out.println(bb.position());//到第二个字节了 //标记 bb.mark(); bb.get(by,2,3); System.out.println(new String(by,2,3)); System.out.println(bb.position());//到第二个字节了 //重置 bb.reset(); System.out.println(bb.position());//位置又回到标记处 } @Test public void run3(){ //非直接缓冲区:通过allocate（）方法分配缓冲区，将缓冲区建立在JVM的内存中 ByteBuffer bb=ByteBuffer.allocate(1024); //直接缓冲区:通过allocateDirect（）方法分配直接缓冲区，将缓冲区建立在物理内存中，可以提高效率 ByteBuffer bb2=ByteBuffer.allocateDirect(1024); }}2.Channel
package com.jxhtyw;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.RandomAccessFile;import java.nio.ByteBuffer;import java.nio.MappedByteBuffer;import java.nio.channels.FileChannel;import java.nio.channels.FileChannel.MapMode;import java.nio.file.Paths;import java.nio.file.StandardOpenOption;import org.junit.Test;/** *通道(Channel)：用于源节点与目标节点的连接，在java NIO 中负责缓冲区中的数据传输， *Channel本身不存储数据，因此需要缓冲区配合进行传输，通道就相当于铁轨，缓冲区就相当于火车 * *JDK 1.7中的NIO 针对各个通道提供了静态方法open() * *通道之间的数据传输 *transferTo() *transferFrom() * * *分散与聚集 *分散读取：将通道中的数据分散到多个缓冲区中去 *聚集写入:将多个缓冲区的数据聚集到通道中去 * * @author dxx * @version 2017-11-02 下午8:33:05 */public class NioChannel { //4.分散与聚集 @Test public void run4() throws IOException{ //1.分散读取 RandomAccessFile raf1=new RandomAccessFile("1.txt", "rw"); //获取通道 FileChannel channel1 = raf1.getChannel(); //分配两个指定大小的缓冲区 ByteBuffer buf1 = ByteBuffer.allocate(100); ByteBuffer buf2 = ByteBuffer.allocate(1024); //构建缓冲区数组 ByteBuffer[] bufArr={buf1,buf2}; //通道读取 channel1.read(bufArr); //切换缓冲区为写模式 for (ByteBuffer byteBuffer : bufArr) { byteBuffer.flip(); } System.out.println(new String(bufArr[0].array(), 0, bufArr[0].limit())); System.out.println("--------------------------"); System.out.println(new String(bufArr[1].array(), 0, bufArr[1].limit())); //2.聚集写入 //聚集写入到2.txt中 RandomAccessFile raf2=new RandomAccessFile("2.txt", "rw"); FileChannel channel2 = raf2.getChannel(); //将缓冲区数组写入通道中 channel2.write(bufArr); } //3.通道之间的数据传输，直接缓冲区 @Test public void run3() throws IOException{ FileChannel inChannel = FileChannel.open(Paths.get("e:/01.avi"), StandardOpenOption.READ); FileChannel outChannel = FileChannel.open(Paths.get("e:/02.avi"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE);// inChannel.transferTo(0, inChannel.size(), outChannel); outChannel.transferFrom(inChannel, 0, inChannel.size()); } //2.利用直接缓冲区完成文件的复制 @Test public void run2() throws IOException{ long start=System.currentTimeMillis(); //获取通道 //读模式 FileChannel inChannel = FileChannel.open(Paths.get("e:/01.avi"), StandardOpenOption.READ); //读写模式 FileChannel outChannel = FileChannel.open(Paths.get("e:/02.avi"), StandardOpenOption.WRITE,StandardOpenOption.READ,StandardOpenOption.CREATE); //内存映射文件 MappedByteBuffer inBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size()); MappedByteBuffer outBuf = outChannel.map(MapMode.READ_WRITE,0,inChannel.size()); //对缓冲区的数据进行读写操作 byte[] by=new byte[inBuf.limit()]; inBuf.get(by); outBuf.put(by); inChannel.close(); outChannel.close(); long end=System.currentTimeMillis(); System.out.println("耗费时间："+(end-start)); } //1.利用通道完成文件的复制（非直接缓冲区） @Test public void run() throws IOException{ long start=System.currentTimeMillis(); FileInputStream fis=null; FileOutputStream fos=null; FileChannel inChannel = null; FileChannel outChannel = null; try { fis=new FileInputStream("e:/01.avi"); fos=new FileOutputStream("e:/02.avi"); inChannel = fis.getChannel(); outChannel = fos.getChannel(); //分配指定大小的缓冲区 ByteBuffer bb = ByteBuffer.allocate(1024); //将通道中的数据存入缓冲区,这个时候的缓冲区是写模式 while(inChannel.read(bb)!=-1){ //将缓冲区切换为读模式 bb.flip(); outChannel.write(bb); bb.clear(); } } catch (Exception e) { e.printStackTrace(); }finally{ fis.close(); fos.close(); inChannel.close(); outChannel.close(); } long end=System.currentTimeMillis(); System.out.println("耗费时间："+(end-start)); }}3.阻塞NIO
package com.jxhtyw;import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.FileChannel;import java.nio.channels.ServerSocketChannel;import java.nio.channels.SocketChannel;import java.nio.file.Paths;import java.nio.file.StandardOpenOption;import org.junit.Test;/** * 阻塞NIO * * @author dxx * @version 2017-11-02 下午9:36:08 */public class NioBlock2 { //1.网络通信客户端 @Test public void client() throws IOException{ //获取通道 SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888)); FileChannel fChannel = FileChannel.open(Paths.get("1.png"), StandardOpenOption.READ); //分配指定大小的缓冲区 ByteBuffer bb = ByteBuffer.allocate(1024); //读取本地文件，并发送到客户端 while(fChannel.read(bb)!=-1){ //将缓冲区转换为写模式 bb.flip(); socketChannel.write(bb); bb.clear(); } //当接收不到缓冲区的数据时，强制关闭通道(阻塞式体现在这里) socketChannel.shutdownOutput(); //接受服务器端的反馈 int len=0; while((len=socketChannel.read(bb))!=-1){ bb.flip(); System.out.println(new String(bb.array(),0,len)); bb.clear(); } //关闭通道 socketChannel.close(); fChannel.close(); } //2.服务端 @Test public void server() throws IOException{ //获取通道 ServerSocketChannel ssChannel = ServerSocketChannel.open(); FileChannel fChannel = FileChannel.open(Paths.get("2.png"), StandardOpenOption.WRITE,StandardOpenOption.CREATE); //绑定连接 ssChannel.bind(new InetSocketAddress(8888)); //获取客户端连接的通道 SocketChannel accept = ssChannel.accept(); //分配指定大小的缓冲区 ByteBuffer bb = ByteBuffer.allocate(1024); //读取本地文件，并发送到客户端 while(accept.read(bb)!=-1){ //将缓冲区转换为写模式 bb.flip(); fChannel.write(bb); bb.clear(); } //发送反馈给客户端 bb.put("接收数据成功".getBytes()); bb.flip(); accept.write(bb); //关闭通道 ssChannel.close(); fChannel.close(); }}运行结果： 
3.非阻塞NIO——简单聊天室的建立
package com.jxhtyw;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.text.SimpleDateFormat;import java.util.Date;import java.util.Iterator;import java.util.Random;import java.util.Scanner;import org.junit.Test;/** * 非阻塞NIO * *一、使用NIO完成网络通信 *1.通道（Channel）:负责连接 *2.缓冲区（Buffer）:负责数据的存取 *3.选择器（Selector）:用于监控IO情况 * * @author dxx * @version 2017-11-05 上午10:42:18 */public class NioNotBlock { //客户端 @Test public void client() throws IOException{ //1.获取通道 SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8888)); //2.切换为非阻塞模式 sChannel.configureBlocking(false); //3.分配指定大小的缓冲区 ByteBuffer bb = ByteBuffer.allocate(1024); //4.发送数据到客户端(实时时间+键盘录入) Scanner sc=new Scanner(System.in); String[] nameArr={"Kobe","James","Iverson","Duncan","Curry","Harden"}; Random rand = new Random(); int i = rand.nextInt(5); SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String date = sdf.format(new Date()); while(sc.hasNext()){ String str = sc.next(); bb.put((nameArr[i]+" "+date+"\n"+str).getBytes()); bb.flip(); sChannel.write(bb); bb.clear(); } //5.关闭通道 sChannel.close(); } //服务端 @Test public void server() throws IOException{ //1.获取通道 ServerSocketChannel ssChannel = ServerSocketChannel.open(); //2.切换为非阻塞模式 ssChannel.configureBlocking(false); //3.绑定连接 ssChannel.bind(new InetSocketAddress(8888)); //4.获取选择器 Selector selector=Selector.open(); //5.将通道注册到选择器上,指定“监听接收事件” ssChannel.register(selector, SelectionKey.OP_ACCEPT); //6.轮询获取选择器上已经“准备就绪”的事件 while(selector.select()>0){ //7.获取当前选择器中所有注册的“选择键（已就绪的监听事件）” Iterator<SelectionKey> it = selector.selectedKeys().iterator(); while(it.hasNext()){ //8.获取准备就绪的事件 SelectionKey sk = it.next(); //9.判断是什么事件准备就绪 if(sk.isAcceptable()){ //10.若是接收就绪，则获取客户端连接 SocketChannel clientCh = ssChannel.accept(); //11.切换非阻塞模式 clientCh.configureBlocking(false); //12.将该通道注册到选择器 clientCh.register(selector,SelectionKey.OP_READ); }else if(sk.isReadable()){ //13.获取当前选择器上“读就绪”的通道 SocketChannel rChannel=(SocketChannel) sk.channel(); //14.读取数据 ByteBuffer bb = ByteBuffer.allocate(1024); int len=0; while((len=rChannel.read(bb))>0){ bb.flip(); System.out.println(new String(bb.array(),0,len)); bb.clear(); } } //15.取消选择键 SelectionKey it.remove(); } } }}聊天室效果：
阅读全文
0 0
- Java NIO及其常用API
- java-String及其常用API
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- Java NIO API详解
- 学习笔记--实现HashMap
- 面向对象--static静态关键字
- SCALA学习
- 习题5.3
- sql 面试题总结
- Java NIO及其常用API
- Tarjan 算法——求解有向图强连通分量
- 二阶指针的运用，字符串的交换
- 公众号后台开发上传文件功能
- Mysql分区
- 缘分天空之Mybatis学习
- Java —— interface接口
- SQUEEZENET
- HTML新特性-关于article和section
