java nio 常见的nio类, nio 写文件方法, nio 比io 的优势

最新推荐文章于 2024-07-31 07:00:00 发布
nx188
最新推荐文章于 2024-07-31 07:00:00 发布
阅读量3.7k
点赞数 2
分类专栏： Java
本文链接：https://blog.csdn.net/nx188/article/details/51753613
版权
Java 专栏收录该内容
68 篇文章 0 订阅
订阅专栏
1..nio是同步非阻塞的意思, 以前的IO 都是阻塞IO, nio是非阻塞IO
2..阻塞非阻塞意思就是, 阻塞是线程一直等, 非阻塞是线程不等. 非阻塞就是来连接我不创建线程, 直到你来IO数据的请求, 即http 包, 我才创建线程, 如代码aaa处
int n = selector.select( ) 就是同步非阻塞的意思 , n代表IO请求的数量, 你来请求之前,我可以做我的事, 不是阻塞等, 你来请求之后即n>0, 我也照样可以做自己的事,
爱什么时候处理IO就什么时候处理IO 即非阻塞就是你来IO我才创建线程去处理
nio 代码如下:
package NIO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.Pipe;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Date;
import java.util.Iterator;
/**
 * 
 * NIO (2) Chanel,chanel 就是通道,ByteBuffer俗称缓冲器,ByteBuffer 底层用byte[]数组存储实现的
 * 以下函数注释中括号的数字对应如下链接中的章节,参考:http://ifeve.com/file-channel/
 * 
 * NIO 和IO 的区别:
 * nio 快,io 慢.(13)unBlockReadTest()函数
 * nio 不阻塞, io阻塞, 未看出
 * nio 可以从文件的指定位置读/写, io做不到  (14)updateFile()函数
 * 
 * @author jaloli
 * 
 */

public class FileChanelTest {
	//(2,3)
	public static void writeAndReadChanel() throws IOException {  //write buffer,read buffer
		RandomAccessFile aFile = new RandomAccessFile("nio-data.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer buf = ByteBuffer.allocate(48);
		int bytesRead = inChannel.read(buf);
		while (bytesRead != -1) {
			System.out.println("Read " + bytesRead);
			buf.flip();//翻转缓冲，使其由能写变成能读
			System.out.println("初始　position　：" +buf.position() + " limit : " + buf.limit() );
			while(buf.hasRemaining()){
				System.out.print( buf.position() + ":" + (char) buf.get() + " ");
			}
			buf.clear();
			bytesRead = inChannel.read(buf);
			System.out.println("\nRead " + bytesRead);
		}
		aFile.close();
	}
	//(4)分散（scatter）从Channel中读取是指在读操作时将读取的数据写入多个buffer中
	//聚集（gather）写入Channel是指在写操作时将多个buffer的数据写入同一个Channel
	public static void writeFileChanel() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer body = ByteBuffer.allocate(6);
		ByteBuffer header = ByteBuffer.allocate(120000000);
		header.put(new byte[]{65,66,67,68,69,70});
		body.put(new byte[]{71,72,73,74,75,76});
		header.flip();
		body.flip();
//		System.out.println(header.getChar());
		ByteBuffer[] bufferArray = {header,body};//这里就是读buffer
		inChannel.write(bufferArray);
		aFile.close();
	}
	
	//(12)非阻塞测试, 如151行注释, 非block 并未发生,存疑
	public static void unBlockWriteTest() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer body = ByteBuffer.allocate(6);
		ByteBuffer header = ByteBuffer.allocate(120000000);
		byte[] needWriteByte = new byte[10000000];
		byte[] needWriteByte1 = new byte[10000000];
		byte[] needWriteByte2 = new byte[10000000];
		byte[] needWriteByte3 = new byte[10000000];
		byte[] needWriteByte4 = new byte[10000000];
		byte[] needWriteByte5 = new byte[10000000];
		byte[] needWriteByte6 = new byte[10000000];
		byte[] needWriteByte7 = new byte[10000000];
		byte[] needWriteByte8 = new byte[10000000];
		byte[] needWriteByte9 = new byte[10000000];
		byte[] needWriteByte10 = new byte[10000000];
		byte[] needWriteByte11 = new byte[10000000];
		for(int i=0;i<10000000;i++){//10000000
			needWriteByte[i] = 1;
			needWriteByte1[i] = 1;
			needWriteByte2[i] = 1;
			needWriteByte3[i] = 1;
			needWriteByte4[i] = 1;
			needWriteByte5[i] = 1;
			needWriteByte6[i] = 1;
			needWriteByte7[i] = 1;
			needWriteByte8[i] = 1;
			needWriteByte9[i] = 1;
			needWriteByte10[i] = 1;
			needWriteByte11[i] = 1;
		}
		header.put(needWriteByte);
		header.put(needWriteByte1);
		header.put(needWriteByte2);
		header.put(needWriteByte3);
		header.put(needWriteByte4);
		header.put(needWriteByte5);
		header.put(needWriteByte6);
		header.put(needWriteByte7);
		header.put(needWriteByte8);
		header.put(needWriteByte9);
		header.put(needWriteByte10);
		header.put(needWriteByte11);
		body.put(new byte[]{71,72,73,74,75,76});//
		header.flip();
		body.flip();
		ByteBuffer[] bufferArray = {header,body};//   这里就是读buffer
		inChannel.write(bufferArray); //  这个会写117M的文件, 这个写的时候,卡住一下,写好后,再继续走下面的代码
		System.out.println("gggggggggggggggggggg");
		aFile.close();
	}
	
	//(13)nio 非阻塞读, 没看出来,但是看出来 nio 性能优于io
	public static void unBlockReadTest() throws IOException {  //write chanel
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		int _5M = 1024*1024*5;
		ByteBuffer dst = ByteBuffer.allocateDirect(1);//_5M
		Date date = new Date();
		System.out.println(String.valueOf(date.getTime()));
		for(int i=0;i<10000000;i++){
			inChannel.read(dst);//这个就是一直在读文件的dst 个字节
//			inChannel.position(3);
//			System.out.println(inChannel.position());//以上两句有效,但是对read()方法无作用
//			System.out.println(byteBufferToString(dst));
		}
		System.out.println(String.valueOf(date.getTime()));//以上读完耗时忽略,是因为NIO面向的是data chunks,而java.io基本上是面向byte
		
		FileInputStream fr = new FileInputStream("nio-data1.txt");
		BufferedInputStream bis = new BufferedInputStream(fr);
		byte[] bytes = new byte[_5M];
		System.out.println(String.valueOf(date.getTime()));
		for(int i=0;i<10000000;i++) {
			System.out.println(bis.read(bytes));
		}
		System.out.println(String.valueOf(date.getTime()));//java io 读完耗时特别长,原因就是链接http://justjavac.iteye.com/blog/1998207 说的io 用吸管吸os给的一盆水 
	}
	
	//(14)nio 可以从文件指定位置写, 从文件指定位置读, io 做不到
	public static void updateFile() throws IOException {
		RandomAccessFile aFile = new RandomAccessFile("nio-data1.txt", "rw");
		FileChannel inChannel = aFile.getChannel();
		ByteBuffer needInsert = ByteBuffer.allocate(216);
		ByteBuffer readIn = ByteBuffer.allocate(216);
		needInsert.put("好".getBytes());
		needInsert.flip();//如果不加这句则无论字母汉字都是出乱码,因为后面的不可预知的字符会以utf-8等编码去解析
		inChannel.write(needInsert,3);//文件指定位置插入,源文件是 gegbbbbbbbbbwqfewq, 文件插入指定位置插入字符后变为  geg好bbbbbbbbbwqfewq
		inChannel.read(readIn, 3);//从指定位置读       我bbbbbbwqfewq
		readIn.flip();
		System.out.println(byteBufferToString(readIn));
		aFile.close();
	}
	
	//(5)transferFrom / transferTo
	public static void transferFromTest() {
		
	}
	
	//(6)selector 不懂干啥的，  浏览器中输入localhost:30/fdg 可以一直打印对象.代码参考：http://www.cnblogs.com/gaotianle/p/3325451.html
	public static void selectorTest() throws IOException {
		int port = 30;
		ServerSocketChannel serverChannel = ServerSocketChannel.open();
		ServerSocket serverSocket = serverChannel.socket();
		Selector selector = Selector.open();
		serverSocket.bind(new InetSocketAddress(port));
		serverChannel.configureBlocking(false);
		serverChannel.register(selector, SelectionKey.OP_ACCEPT);// 第二个参数是四种事件。这样serverChannel
																	// 作为一个channel
																	// 就注册到selector
																	// 上了
		while (true) {//<strong>selector 负责监听channel上有无数据,监听到后,channel 去read()拿数据</strong>
			int n = selector.select();//这里就是同步非阻塞, 也就是nio同步非阻塞的意思所在aaa
			if (n == 0) {             //但是这里非阻塞虽然不用一直等IO请求, 但也在一直轮询, 所以比较耗费资源, 因此出现aio
				continue; // nothing to do,其实这里可以做别的事,即非阻塞, 做一定的事后, 可以再selector.select() 判断有无IO请求到来,而不是一来个连接,就创建线程等待IO.
			}
			Iterator it = selector.selectedKeys().iterator();
			while (it.hasNext()) {							//当然这里如果来了IO请求, 那么本例没创建线程,而是用当前线程去处理IO数据
				SelectionKey key = (SelectionKey) it.next();
				if (key.isAcceptable()) {
					ServerSocketChannel serverchanel = (ServerSocketChannel) key.channel();
					SocketChannel channel = serverchanel.accept();
					if (channel == null) {
						;// handle code, could happen
					}
					channel.configureBlocking(false);// selector.select
														// 来选择已经注册的多个通道之一
					channel.register(selector, SelectionKey.OP_READ);
				} else if (key.isReadable()) {
					SocketChannel channel = (SocketChannel) key.channel(); // 通过selector
																			// 的key
																			// 拿到channel
					ByteBuffer buffer = ByteBuffer.allocate(48);// channel
																// 的东西落到buffer
																// 里,进而转化成byte，转化成string
					int read = channel.read(buffer);
					byte[] data = buffer.array();
					String message = new String(data);
					System.out.println("接收到的消息是： " + message);
				} else if (key.isWritable()) {

				} else if (key.isConnectable()) {
					SelectableChannel chanel = key.channel();
					System.out.println(chanel.toString());
				}
				it.remove();
			}
		}
	}
	//ByteBuffer to String
	private static String byteBufferToString(ByteBuffer buf) {
		CharBuffer charBuffer = null;
		try{
			if(buf.position() != 0)
				buf.flip();   //flip() 函数是让  ByteBuffer 对象的position 变为0. 这里不flip()打不出来ByteBuffer 缓冲区的数据
			Charset charset = Charset.forName("UTF-8");
			CharsetDecoder decoder = charset.newDecoder();
			charBuffer = decoder.decode(buf);
			return charBuffer.toString();
		} catch(Exception ex) {
			ex.printStackTrace();
		}
		return null;
	}
	
	//(7)FileChannel
	public static void fileChannelTest() throws IOException{
		//FileChannel 读数据
		RandomAccessFile rFile = new RandomAccessFile("D:/xiecheng/EclipseWorkingspace/WorkspaceLearning/jsp_api/src/FileChannelReadTest.txt", "rw");
		FileChannel inChannel = rFile.getChannel();
		ByteBuffer buf = ByteBuffer.allocate(48);
		int bytesRead = inChannel.read(buf);
		String readFileContent = byteBufferToString(buf);
		System.out.println("读文件结果为: "+readFileContent);
		
		//FileChannel 写数据
		RandomAccessFile wFile = new RandomAccessFile("D:/xiecheng/EclipseWorkingspace/WorkspaceLearning/jsp_api/src/FileChannelWriteTest.txt", "rw");
		FileChannel outChannel = wFile.getChannel();
		String needWrite = "我被写入文件aaa";
		ByteBuffer needWriteBuf = ByteBuffer.allocate(48); 
		needWriteBuf.clear();
		needWriteBuf.put(needWrite.getBytes());
		needWriteBuf.flip();
		while(needWriteBuf.hasRemaining()) {
			outChannel.write(needWriteBuf);
		}
		System.out.println("写文件结果请看文件本身,写的内容是:"+needWrite);
	}
	
	//(8)SocketChannel如上面(6)  
	
	//(10)DatagramChannel实现UDP传输,使用如下两个函数,  参考http://www.cnblogs.com/bronte/articles/1966607.html
	public static void socketChannelServerTest() throws IOException{
		DatagramChannel channel = DatagramChannel.open();
		channel.socket().bind(new InetSocketAddress(9991));
		ByteBuffer buf = ByteBuffer.allocate(48);
		buf.clear();
		channel.receive(buf);
		String readFileContent = byteBufferToString(buf);
		System.out.println("SocketChannel 接收的结果为: "+readFileContent);
	}
	//这个客户端函数在另一个类中运行,方便查看客户端给服务端发的数据
	public static void socketChannelClientTest() throws IOException{
		DatagramChannel channel = DatagramChannel.open();
		String newData = "New String to write to file..." + System.currentTimeMillis();
		ByteBuffer buf = ByteBuffer.allocate(48);
		buf.clear();
		buf.put(newData.getBytes());
		buf.flip();
		int bytesSent = channel.send(buf, new InetSocketAddress(9991));

	}
	//(11)Pipe
	public static void pipeTest() throws IOException {
		//写
		Pipe pipe = Pipe.open();
		Pipe.SinkChannel sinkChannel = pipe.sink();
		String newData = "New String to write to file..." + System.currentTimeMillis();
		ByteBuffer needBeWriteBuf = ByteBuffer.allocate(48);//此时needBeWriteBuf 这个ByteBuffer 的limit 值是0
		needBeWriteBuf.clear();
		needBeWriteBuf.put(newData.getBytes());
		System.out.println("needBeWriteBuf 的postion 和 limit 分别是: "+needBeWriteBuf.position() +", "+ needBeWriteBuf.limit());
		needBeWriteBuf.flip(); //position 设置为0,即顶头,读写公用一个position
		while(needBeWriteBuf.hasRemaining()) { //这个一次可能写0个到多个,所以需要重复写
			int byteWriteNum = sinkChannel.write(needBeWriteBuf);//write 之后,needBeWriteBuf 的position 就变成了43
			System.out.println("往sinkChannel 写的数据字节数为:" + byteWriteNum + ", 写的数据为: " + newData);
		}
		//读
		Pipe.SourceChannel sourceChannel = pipe.source();
		ByteBuffer needReadToBuf = ByteBuffer.allocate(48);
		int byteReadNum = sourceChannel.read(needReadToBuf);
		System.out.println("read 之后, postion is : "+needReadToBuf.position());  //read 一次, position 变为43
		String sourceChannelContent = byteBufferToString(needReadToBuf);
		System.out.println("sourceChannel 接收的结果长度为: " + byteReadNum +", sourceChannel 接收的结果为: "+sourceChannelContent);
	}
	
	//ByteBuffer 缓冲区
	public static void byteBufferTest(){
		ByteBuffer needBeWriteBuf = ByteBuffer.allocate(48);
		needBeWriteBuf.clear();
		needBeWriteBuf.put("我".getBytes());
		needBeWriteBuf.put("我".getBytes());
		needBeWriteBuf.put("我".getBytes());
//		needBeWriteBuf.clear(); //buffer.clear()  缓冲区清空了
		needBeWriteBuf.put("你".getBytes()); //正常追加到缓冲区, 我我我你
		
		String sourceChannelContent = byteBufferToString(needBeWriteBuf);
		System.out.println("ByteBuffer 缓冲区内容是  is " + sourceChannelContent);
	}
	
	public static void main(String[] args) throws IOException {
//		writeAndReadChanel();
//		writeFileChanel();
//		selectorTest();
//		fileChannelTest();
//		socketChannelServerTest();
//		pipeTest();
//		byteBufferTest();
//		unBlockWriteTest();
//		unBlockReadTest();
		updateFile();
	}
}