java7 AIO / NIO 2 小记
概述
JDK7 已经大致确定发布时间。JSR 203 提出很久了。2009.11.13，JDK7 M5（b76）已经发布。JSR 203 习惯上称为 NIO.2，主要包括新的：
- 异步 I/O（简称 AIO）；
- Multicase 多播；
- Stream Control Transport Protocol（SCTP）；
- 文件系统 API；
- 以及一些 I/O API 的更新，例如：java.io.File.toPath，NetworkChannel 的完整抽象，等等。
BIO -> NIO -> AIO，Jva IO 性能逐步突飞猛进，谁还在说IO是Java的硬伤！
BIO几乎已经是老掉牙的东西，最简单，性能很差，不详说了；
NIO让人惊讶的IO性能飞跃，由于java5就开始有了，网上教程也满大街，著名的实用框架有 Netty 和 Mina，不多说了；
AIO，异步IO，这个就不是很为人所很熟知了，java7以后引入的异步IO，引入不少的新操作，小记下：
文件系统 API
File类其实名字有点儿误导人，它并不是指真正的文件，它的本质是用一种依赖系统的路径名来描述文件或者目录。这个通俗点儿讲不就是path么
public static void main(String[] args) {
//PS: task 是桌面上的一个文本文件
//获得path方法一,e:/logs/access.log
Path path = FileSystems.getDefault().getPath("/home/conquer/Desktop", "task");
System.out.println(path.getNameCount());
//获得path方法二，用File的toPath()方法获得Path对象
File file = new File("/home/conquer/Desktop/task");
Path pathOther = file.toPath();// File 到 Paht的转换
//0,说明这两个path是相等的
System.out.println(path.compareTo(pathOther));
//获得path方法三
Path path3 = Paths.get("/home/conquer/Desktop", "task");
System.out.println(path3.toString());
//join two paths
Path path4 = Paths.get("/home/conquer/Desktop");
System.out.println("path4: " + path4.resolve("task"));
System.out.println("--------------分割线---------------");
try {
if(Files.isReadable(path)){
//注意此处的newBufferedRead的charset参数，如果和所要读取的文件的编码不一致，则会抛出异常
//java的新特性，不用自己关闭流
BufferedReader br = Files.newBufferedReader(path, Charset.defaultCharset());//new BufferedReader(new FileReader(new File("e:/logs/access.log")));//
String line = "";
while((line = br.readLine()) != null){
System.out.println(line);
}
br.close();
}else{
System.err.println("cannot readable");
}
} catch (IOException e) {
System.err.println("error charset");
}
}
public static void main0(String[] args) {
/** nio2 */
Path file = Paths.get("/home/conquer/Desktop/task");
System.out.println("file name:" + file.getFileName());
System.out.println("name count:" + file.getNameCount());
System.out.println("parent:" + file.getParent() + " root:"
+ file.getRoot());
File file1=file.toFile();
System.out.println(file1.exists());
//其他定义方式
/**Define an Absolute Path*/
// Path path = Paths.get("C:/rafaelnadal/tournaments/2009/BNP.txt");
// Path path = Paths.get("C:/rafaelnadal/tournaments/2009", "BNP.txt");
// Path path = Paths.get("C:", "rafaelnadal/tournaments/2009", "BNP.txt");
// Path path = Paths.get("C:", "rafaelnadal", "tournaments", "2009", "BNP.txt");
// /**Define a Path Relative to the File Store Root*/
// Path path = Paths.get("/rafaelnadal/tournaments/2009/BNP.txt");
// Path path = Paths.get("/rafaelnadal","tournaments/2009/BNP.txt");
// /**Define a Path Relative to the Working Folder*/
// Path path = Paths.get("rafaelnadal/tournaments/2009/BNP.txt");
// Path path = Paths.get("rafaelnadal","tournaments/2009/BNP.txt");
}异步 I/O（简称 AIO）
- AIO 的核心概念：发起非阻塞方式的 I/O 操作。当 I/O 操作完成时通知。
- 应用程序的责任就是：什么时候发起操作？ I/O 操作完成时通知谁？
AIO 的 I/O 操作，有两种方式的 API 可以进行：Future 方式 和 Callback 方式。
Future 方式：即提交一个 I/O 操作请求（accept/read/write），返回一个 Future。然后您可以对 Future 进行检查（调用get(timeout)），确定它是否完成，或者阻塞 IO 操作直到操作正常完成或者超时异常。使用 Future 方式很简单，需要注意的是，因为Future.get()是同步的，所以如果不仔细考虑使用场合，使用 Future 方式可能很容易进入完全同步的编程模式，从而使得异步操作成为一个摆设。如果这样，那么原来旧版本的 Socket API 便可以完全胜任，大可不必使用异步 I/O.
Callback 方式：即提交一个 I/O 操作请求，并且指定一个 CompletionHandler。当异步 I/O 操作完成时，便发送一个通知，此时这个 CompletionHandler 对象的 completed 或者 failed 方法将会被调用。
JAVA AIO 示例代码：
服务端：
package aio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.Charset;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class AIOServer {
public final static int PORT = 9888;
private AsynchronousServerSocketChannel server;
public AIOServer() throws IOException {
server = AsynchronousServerSocketChannel.open().bind(
new InetSocketAddress(PORT));
}
public void startWithFuture() throws InterruptedException,
ExecutionException, TimeoutException {
while (true) {// 循环接收客户端请求
Future future = server.accept();
AsynchronousSocketChannel socket = future.get();// get() 是为了确保 accept 到一个连接
handleWithFuture(socket);
}
}
public void handleWithFuture(AsynchronousSocketChannel channel) throws InterruptedException, ExecutionException, TimeoutException {
ByteBuffer readBuf = ByteBuffer.allocate(2);
readBuf.clear();
while (true) {// 一次可能读不完
//get 是为了确保 read 完成，超时时间可以有效避免DOS攻击，如果客户端一直不发送数据，则进行超时处理
Integer integer = channel.read(readBuf).get(10, TimeUnit.SECONDS);
System.out.println("read: " + integer);
if (integer == -1) {
break;
}
readBuf.flip();
System.out.println("received: " + Charset.forName("UTF-8").decode(readBuf));
readBuf.clear();
}
}
public void startWithCompletionHandler() throws InterruptedException,
ExecutionException, TimeoutException {
server.accept(null,
new CompletionHandler() {
public void completed(AsynchronousSocketChannel result, Object attachment) {
server.accept(null, this);// 再此接收客户端连接
handleWithCompletionHandler(result);
}
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
});
}
public void handleWithCompletionHandler(final AsynchronousSocketChannel channel) {
try {
final ByteBuffer buffer = ByteBuffer.allocate(4);
final long timeout = 10L;
channel.read(buffer, timeout, TimeUnit.SECONDS, null, new CompletionHandler() {
@Override
public void completed(Integer result, Object attachment) {
System.out.println("read:" + result);
if (result == -1) {
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
return;
}
buffer.flip();
System.out.println("received message:" + Charset.forName("UTF-8").decode(buffer));
buffer.clear();
channel.read(buffer, timeout, TimeUnit.SECONDS, null, this);
}
@Override
public void failed(Throwable exc, Object attachment) {
exc.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String args[]) throws Exception {
// new AIOServer().startWithFuture();
new AIOServer().startWithCompletionHandler();
Thread.sleep(100000);
}
} 客户端：
package aio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
public class AIOClient {
public static void main(String... args) throws Exception {
AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
client.connect(new InetSocketAddress("localhost", 9888)).get();
client.write(ByteBuffer.wrap("123456789".getBytes()));
Thread.sleep(1111111);
}
}ＡＩＯ模型，简单，高效，以后的ＩＯ通信就用它了！！！