java非阻塞队列使用 java阻塞和非阻塞区别

在讲 NIO之前先来回顾一下这样几个概念：同步与异步，阻塞与非阻塞。

同步与异步

同步： 同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。
异步： 异步就是发起一个调用后，立刻得到被调用者的回应表示已接收到请求，但是被调用者并没有返回结果，此时我们可以处理其他的请求，被调用者通常依靠事件，回调等机制来通知调用者其返回结果。
同步和异步的区别最大在于异步的话调用者不需要等待处理结果，被调用者会通过回调等机制来通知调用者其返回结果。

阻塞和非阻塞

阻塞： 阻塞就是发起一个请求，调用者一直等待请求结果返回，也就是当前线程会被挂起，无法从事其他任务，只有当条件就绪才能继续。
非阻塞： 非阻塞就是发起一个请求，调用者不用一直等着结果返回，可以先去干其他事情。
那么同步阻塞、同步非阻塞和异步非阻塞又代表什么意思呢？

举个生活中简单的例子，你妈妈让你烧水，小时候你比较笨啊，在哪里傻等着水开（同步阻塞）。等你稍微再长大一点，你知道每次烧水的空隙可以去干点其他事，然后只需要时不时来看看水开了没有（同步非阻塞）。后来，你们家用上了水开了会发出声音的壶，这样你就只需要听到响声后就知道水开了，在这期间你可以随便干自己的事情，你需要去倒水了（异步非阻塞）。

Java NIO简介
Java NIO （ New IO ）是从 Java 1.4 版本开始引入的一个新的 IO API ，
可以替代标准的 Java IO API 。NIO 与原来的 IO 有同样的作用和目的，但是使用的方式完全不同， NIO 支持面向缓冲区的、基于通道的 IO 操作。 NIO 将以更加高效的方式进行文件的读写操作.

Java IO 与 NIO 的区别

通道（ Channel ）与缓冲区（Buffer)

Java NIO 系统的核心在于：通道 (Channel) 和缓冲区(Buffer) 。

通道表示打开到 IO 设备 ( 例如：文件、套接字 ) 的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。

简而言之， Channel 负责传输， Buffer 负责存储

缓冲区(Buffer)
缓冲区（ Buffer ）：一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。
Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。
Buffer 就像一个数组，可以保存多个相同类型的数据。
根据数据类型不同 (boolean 除外 ) ，有以下 Buffer 常用子类：
ByteBuffer
CharBuffer
ShortBuffer
IntBuffer
LongBuffer
FloatBuffer
DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据，只是各自
管理的数据类型不同而已。都是通过如下方法获取一个 Buffer对象
static XxxBuffer allocate(int capacity) : 创建一个容量为 capacity 的 XxxBuffer 对象

缓冲区的基本属性
Buffer 中的重要概念：

 容量 (capacity) ： 表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创
建后不能更改。

 限制 (limit) ： 第一个不应该读取或写入的数据的索引，即位于 limit 后的数据
不可读写。缓冲区的限制不能为负，并且不能大于其容量。

 位置 (position) ： 下一个要读取或写入的数据的索引。缓冲区的位置不能为
负，并且不能大于其限制

 标记 (mark) 与重置 (reset) ： 标记是一个索引，通过 Buffer 中的 mark() 方法
指定 Buffer 中一个特定的 position ，之后可以通过调用 reset() 方法恢复到这
个 position.
标记、位置、限制、容量遵守以下不变式：
0 <= mark <= position <= limit <= capacity

缓冲区的常用方法
缓冲区存取数据的两个核心方法：

put() : 存入数据到缓冲区中

get() : 获取缓冲区中的数据

flip(); 切换读取数据模式

rewind() : 可重复读

clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态

mark() : 标记是一个索引，通过 Buffer 中的 mark() 方法

指定 Buffer 中一个特定的 position ，之后可以通过调用 reset() 方法恢复到这

个 position.

@Test
	public void test1() {
		String str="abcdefg";
		//分配一个指定大小的缓冲区
		ByteBuffer buffer=ByteBuffer.allocate(1024);
		System.out.println("---allocate()--------");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		
		//利用put()存入数据到缓冲区
		buffer.put(str.getBytes());
		System.out.println("-------put()------");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		
		//切换读取数据模式
		buffer.flip();
		System.out.println("-----flip()--------");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		
		//利用get()读取缓冲区中的数据
		byte[] bytes=new byte[buffer.limit()];
		buffer.get(bytes);
		System.out.println(new String(bytes,0,bytes.length));
		System.out.println("-----get()-------");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		
		//rewind():可重复读
		buffer.rewind();
		System.out.println("-----rewind()------");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		
		//clear():清空缓存区，但是缓存区的数据依然存在，只是处于被"遗忘"的状态
		buffer.clear();
		System.out.println("------clear()-----");
		System.out.println(buffer.position());
		System.out.println(buffer.limit());
		System.out.println(buffer.capacity());
		System.out.println((char)buffer.get());
	}

直接与非直接缓冲区
字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在
此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），
虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。

直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法 来创建。此方法返回的 缓冲区进行分配和取消
分配所需成本通常高于非直接缓冲区 。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对
应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的
本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好
处时分配它们。

直接字节缓冲区还可以通过 FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建。该方法返回
MappedByteBuffer 。 Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在
访问期间或稍后的某个时间导致抛出不确定的异常。

字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在
性能关键型代码中执行显式缓冲区管理。

内存映射文件为什么效率高
文件i/o的读操作，会先向文件设备发起读请求，然后驱动把请求要读的数据读取到文件的缓冲区中，这个缓冲区位于内核，然后再把这个缓冲区中的数据复制到程序虚拟地址空间中的一块区域中。

文件i/o的写操作，会向文件设备发起写请求，驱动把要写入的数据复制到程序的缓冲区中，位于用户空间，然后再把这个缓冲区的数据复制到文件的缓冲区中。

内存映射文件，是把位于硬盘中的文件看做是程序地址空间中一块区域对应的物理存储器，文件的数据就是这块区域内存中对应的数据，读写文件中的数据，直接对这块区域的地址操作，就可以，减少了内存复制的环节。

所以说，内存映射文件比起文件I/O操作，效率要高，而且文件越大，体现出来的差距越大。

通道(Channel)

通道（ Channel ）：由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。

Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

Java 为 Channel 接口提供的最主要实现类如下

本地文件传输通道

FileChannel ：用于读取、写入、映射和操作文件的通道

网络数据传输的通道
DatagramChannel ：通过 UDP 读写网络中的数据通道
SocketChannel ：通过 TCP 读写网络中的数据。
ServerSocketChannel ：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel

获取通道

获取通道的一种方式是对支持通道的对象调用

getChannel() 方法。支持通道的类如下：

本地I/O

FileInputStream

FileOutputStream

RandomAccessFile

网络 I/O
DatagramSocket
Socket
ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道。
例如:
在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()
//打开一个读取的通道
FileChannel in = FileChannel.open(Paths.get(“MyTest.java”), StandardOpenOption.READ);
//打开一个写的通道
FileChannel out = FileChannel.open(Paths.get(“MyTest.java”),StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()

通道的数据传输
将 Buffer 中数据写入 Channel
例如：inChannel.read(byteBuffer)
从 Channel 读取数据到 Buffer
例如：outChannel.write(byteBuffer);

列文件复制:
使用非直接缓冲区:

@Test
	public void test2() throws IOException {
		//创建文件输入输出流
		FileInputStream fin=new FileInputStream("F:/1.txt");
		FileOutputStream fou=new FileOutputStream("F:/2.txt");
		//文件输入输出流的getChannel()方法获取通道
		FileChannel finChannel=fin.getChannel();
		FileChannel fouChannel=fou.getChannel();
	    //获取非直接缓冲区
		ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
		//将通道中的数据放入缓冲区
		while(finChannel.read(byteBuffer)!=-1) {
			//切换读取模式
			byteBuffer.flip();
			//将缓冲区的数据写入通道中
			fouChannel.write(byteBuffer);
			//清空缓冲区
			byteBuffer.clear();
		}
		//释放资源
		fin.close();
		fou.close();
		finChannel.close();
		fouChannel.close();
	}

使用直接缓冲区

@Test
	public void test3() throws IOException {
		//通过文件通道的静态方法，打开读写通道
		//参数1：通过Paths获取源文件的路径
		//参数2：操作模式  StandardOpenOption.READ 读取模式
		//打开读取文件的通道
		FileChannel finChannel=FileChannel.open(Paths.get("F:/1.txt"), StandardOpenOption.READ);
		//打开写入的通道，模式要读还要写，StandardOpenOption.CREATE 意思是文件不存在就创建,如果存在就覆盖
		//StandardOpenOption.CREATE_NEW 意思是文件不存在就创建,如果存在就报错
		FileChannel fouChannel=FileChannel.open(Paths.get("F:/2.txt"), StandardOpenOption.READ,
				StandardOpenOption.WRITE,StandardOpenOption.CREATE);
		//操作内存映射文件(也就是这个缓存区在物理内存中)
		MappedByteBuffer inBuffer=finChannel.map(FileChannel.MapMode.READ_ONLY, 0, finChannel.size());
		MappedByteBuffer ouBuffer=fouChannel.map(FileChannel.MapMode.READ_WRITE,0, finChannel.size());
		//直接对缓冲区进行读写操作
		byte[] bytes=new byte[inBuffer.limit()];
		inBuffer.get(bytes);
		ouBuffer.put(bytes);
		//释放资源
		finChannel.close();
		fouChannel.close();
	}

分散 (Scatter)和聚集(Gather)

分散读取（ Scattering Reads ）是指从 Channel 中读取的数据“分散”到多个Buffer缓冲区中

注:按照缓冲区的顺序，从Channel中读取的数据依次将Buffer填满。聚集写入（ Gathering Writes ）是指将多个 Buffer缓冲区 中的数据“聚集”到 Channel 。

注:按照缓冲区的顺序，写入position和limit之间的数据到Channel.

@Test
	public void test4() throws IOException {
	
		RandomAccessFile in=new RandomAccessFile("F:/1.txt", "rw");
		RandomAccessFile out=new RandomAccessFile("F:/3.txt","rw");
		//获取读取通道
		FileChannel inChannel=in.getChannel();
		//创建多个缓冲区
		ByteBuffer buffer1=ByteBuffer.allocate(1);
		ByteBuffer buffer2=ByteBuffer.allocate(20);
		//分散读取到多个缓冲区中
		ByteBuffer[] buffers=new ByteBuffer[] {buffer1,buffer2};//把多个缓冲区放到一个大的数组中
		long read=inChannel.read(buffers);//把这个大的缓冲区传进去
		//可以看看每个缓存区中读入的数据
//		buffers[0].flip();//切换到读取模式，看一下第一个缓存区，读入的100个字节；
//		byte[] arry=buffers[0].array();//把 ByteBuffer转换成字节数组
//		String str=new String(arry,0,buffers[0].limit());
//		System.out.println(str);
		
		//把每个缓冲区，切换到读取模式
		for (ByteBuffer byteBuffer : buffers) {
			byteBuffer.flip();
		}
		
		//聚集写入
		FileChannel outChannel=out.getChannel();
		outChannel.write(buffers);
		
		//释放资源
		inChannel.close();
		outChannel.close();
		
	}