NIO 之 Channel
可参考之前写过的文章：NIO 之 Channel实现原理
概述
通道（ Channel）是 java.nio 的主要创新点。它们既不是一个扩展也不是一项增强，而是全新、极好的 Java I/O 示例，提供与 I/O 服务的直接连接。 Channel 用于在字节缓冲区和位于通道另一侧的实体（通常是一个文件或套接字）之间有效地传输数据。
Channel 接口定义
public interface Channel extends Closeable {
public boolean isOpen();
public void close() throws IOException;
}Channel 接口，只抽象了 isOpen() 方法和 close() 方法。
是否感觉很奇怪，为什么没有 open() 方法？
Channel 概述
I/O 分为File I/O 和 Stream I/O。
File I/O 对应的是文件(file)通道。
Stream I/O 对应的是（ socket）通道。
FileChannel 类和三个 socket 通道类： SocketChannel、 ServerSocketChannel 和 DatagramChannel。
通道可以以多种方式创建。 Socket 通道有可以直接创建新 socket 通道的工厂方法。但是一个FileChannel 对象却只能通过在一个打开的 RandomAccessFile、 FileInputStream 或 FileOutputStream对象上调用 getChannel( )方法来获取。您不能直接创建一个 FileChannel 对象。（这也是 Channel 接口没有定义 open() 方法的原因）。
ByteChannel
通过源码发现每一个 file 或 socket 通道都实现ByteChannel。
ByteChannel
public interface ByteChannel extends ReadableByteChannel, WritableByteChannel { }ReadableByteChannel
public interface ReadableByteChannel extends Channel {
public int read(ByteBuffer dst) throws IOException;
}WritableByteChannel
public interface WritableByteChannel extends Channel{
public int write(ByteBuffer src) throws IOException;
}
通道可以是单向或者双向的。实现这两种接口其中之一的类都是单向的，只能在一个方向上传输数据。如果一个类同时实现这两个接口，那么它是双向的，可以双向传输数据。
每一个 file 或 socket 通道都实现全部三个接口。从类定义的角度而言，这意味着全部 file 和 socket 通道对象都是双向的。这对于 sockets 不是问题，因为它们一直都是双向的，不过对于 files 却是个问题了。
一个文件可以在不同的时候以不同的权限打开。从 FileInputStream 对象的getChannel( )方法获取的 FileChannel 对象是只读的，不过从接口声明的角度来看却是双向的，因为
FileChannel 实现 ByteChannel 接口。在这样一个通道上调用 write( )方法将抛出未经检查的NonWritableChannelException 异常，因为 FileInputStream 对象总是以 read-only 的权限打开文件。一个连接到只读文件的 Channel 实例不能进行写操作，即使该实例所属的类可能有 write( )方法。基于此，程序员需要知道通道是如何打开的，避免试图尝试一个底层 I/O服务不允许的操作。
阻塞非阻塞
通道可以以阻塞（ blocking）或非阻塞（ nonblocking）模式运行。非阻塞模式的通道永远不会让调用的线程休眠。请求的操作要么立即完成，要么返回一个结果表明未进行任何操作。只有面向流的（ stream-oriented）的通道，如 sockets 和 pipes 才能使用非阻塞模式。file 通道是不能以非阻塞的模式运行。
Channel.close()
与缓冲区（Buffer）不同，通道（Channel）不能被重复使用。一个打开的通道即代表与一个特定 I/O 服务的特定连接并封装该连接的状态。当通道关闭时，那个连接会丢失，然后通道将不再连接任何东西。
调用通道的close( )方法时，可能会导致在通道关闭底层I/O服务的过程中线程暂时阻塞，哪怕该通道处于非阻塞模式。通道关闭时的阻塞行为（如果有的话）是高度取决于操作系统或者文件系统的。
源码简略如下：
//该代码是 FileChannel 的关闭方法 (在FileChannel 的父类 AbstractInterruptibleChannel 中)
public final void close() throws IOException {
synchronized (closeLock) {
if (!open)
return;
open = false;
implCloseChannel();
}
}从上面代码中可以分析出在一个通道上多次调用close( )方法是没有坏处的，但是如果第一个线程在close( )方法中阻塞（使用synchronized 锁），那么在它完成关闭通道之前，任何其他调用close( )方法都会阻塞。后续在该已关闭的通道上调用close( )不会产生任何操作，只会立即返回。
Channel.isOpen( )
可以通过 isOpen( )方法来测试通道的开放状态。如果返回 true 值，那么该通道可以使用。如果返回 false 值，那么该通道已关闭，不能再被使用。尝试进行任何需要通道处于开放状态作为前提的操作，如读、写等都会导致 ClosedChannelException 异常。
源码简略如下：
//该代码在FileChannel 的子类中实现的
public class FileChannelImpl extends FileChannel{
public int read(ByteBuffer dst) throws IOException {
ensureOpen();
......
}
public int write(ByteBuffer src) throws IOException {
ensureOpen();
......
}
private void ensureOpen() throws IOException {
if (!isOpen())
throw new ClosedChannelException();
}
}通道响应 Interrupt 中断
通道引入了一些与关闭和中断有关的新行为。通道实现 InterruptibleChannel 接口。
如果一个线程在一个通道上被阻塞并且同时被中断（由调用该被阻塞线程的 interrupt( )方法的另一个线程中断），那么该通道将被关闭，该被阻塞线程也会产生一个 ClosedByInterruptException 异常。
源码简略如下：
public class FileChannelImpl extends FileChannel{
public int write(ByteBuffer src) throws IOException {
......
end(n > 0);
......
}
public int read(ByteBuffer dst) throws IOException {
......
end(n > 0);
......
}
public FileLock lock(long position, long size, boolean shared) throws IOException {
......
end(n > 0);
......
}
.......
}public abstract class AbstractInterruptibleChannel
implements Channel, InterruptibleChannel {
protected final void end(boolean completed)
throws AsynchronousCloseException
{
blockedOn(null);
Thread interrupted = this.interrupted;
if (interrupted != null && interrupted == Thread.currentThread()) {
interrupted = null;
throw new ClosedByInterruptException();
}
if (!completed && !open)
throw new AsynchronousCloseException();
}
......
}Interrupt 关闭 Channel 实例
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ChannelInterruptDemo {
public static void main(String[] args) throws Exception {
FileChannel fc = new RandomAccessFile(new File("d:/a.txt"), "rw").getChannel();
System.out.println("Channel isOpen ： " + fc.isOpen());
Thread t = new Thread(new Task(fc));
t.start();
t.interrupt();
t.join();
System.out.println("Channel isOpen ： " + fc.isOpen());
fc.close();
}
}
class Task implements Runnable{
FileChannel fc;
public Task(FileChannel fc) {
this.fc = fc;
}
@Override
public void run() {
try {
fc.position(Integer.MAX_VALUE/2);
fc.write(ByteBuffer.wrap("hello".getBytes()));
} catch (IOException e) {
e.printStackTrace();
}
}
}运行结果：
输出结果
从结果中发现，只要Channel 所在的线程 interrupt 就会自动关闭channel。