先来了解几个关键词：
1、DMA控制器：通俗来讲，就是操作内存和硬盘之间数据的复制，可以让当前线程释放CPU，在DMA出来之前，是由CPU来做这事的
2、pageCache：就是一个高速缓冲区，缓存IO（大部分IO操作都是缓存IO）中用户态和内核态之间的一个桥梁
3、缓存IO，直接IO
缓存IO：大部分IO使用的一种方式
直接IO：在AIO（nio2)中使用到
4、mmap：就是用户进程虚拟内存地址和内核内存间直接建立映射关系，用户态可以直接访问内核态内存中的数据，且访问磁盘文件时无需再进行系统调用
5、sendfile：可以把pageCache中的数据直接发给网关/磁盘文件，即两个文件描述符之间可以直接进行数据复制，实现了真正的零拷贝
BIO
?先来看下用bio进行socket通信代码：
socket client:?
public static void bioSend(Path filename) throws IOException {
long start = System.currentTimeMillis();
Socket socket = new Socket("127.0.0.1",8888);
BufferedOutputStream outputStream = new BufferedOutputStream(socket.getOutputStream());
try (BufferedInputStream fileInputStream = new BufferedInputStream(new FileInputStream(filename.toFile()))) {
byte[] bytes = new byte[1024*1024*10];
while (fileInputStream.read(bytes) != -1){
outputStream.write(bytes);
}
} catch (IOException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("bio执行耗时："+(end-start));
}socket server:??
public class SocketServer {
public static void main(String[] args) {
try {
ServerSocket ss = new ServerSocket(8888);
System.out.println("启动服务器....");
Socket s = ss.accept();
BufferedInputStream inputStream = new BufferedInputStream(s.getInputStream());
byte[] bytes = new byte[1024*1024*10];
while (inputStream.read(bytes) != -1){
System.out.println(bytes.length);
}
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}传统fileInputStream.read(bytes) != -1调用了read0本地方法，进行了一次系统调用
private native int read0() throws IOException;在outputStream.write(bytes);调用了socketWrite0本地方法，进行了一次系统调用
private native void socketWrite0(FileDescriptor fd, byte[] b, int off,
int len) throws IOException;
?在代码中?fileInputStream.read(bytes) 把pageCache的数据copy到byte数组中是cpu操作
outputStream.write(bytes);把数组中的数据copy到socket也是cpu操作
则：
1、发生了两次系统调用，4次用户态和内核态上下文切换，一次系统调用两次上下文切换
2、两次DMA copy和两次CPU copy
nio-内存映射MappedByteBuffer
?先来看下用MappedByteBuffer进行socket通信代码：
?socket client:
public static void mappedFile(Path filename) throws IOException {
long start = System.currentTimeMillis();
//1.打开通道
SocketChannel socketChannel=SocketChannel.open();
//2.连接指定ip和端口号
socketChannel.connect (new InetSocketAddress("127.0.0.1",8888));
//3.写出数据
try (FileChannel fileChannel = FileChannel.open(filename)) {
long size = fileChannel.size();//2147483647
MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, size);
socketChannel.write(mappedByteBuffer);
} catch (IOException e) {
e.printStackTrace();
}
//4.释放资源
socketChannel.close();
long end = System.currentTimeMillis();
System.out.println("mappedFile执行耗时："+(end-start));
}socket server:?
public class NioSocketServer {
static List<SocketChannel> channelList = new ArrayList<>();
public static void main(String[] args) throws IOException {
int size = 0;
// 创建NIO ServerSocketChannel,与BIO的serverSocket类似
ServerSocketChannel serverSocket = ServerSocketChannel.open();
serverSocket.socket().bind(new InetSocketAddress(8888));
// 设置ServerSocketChannel为非阻塞
serverSocket.configureBlocking(false);
System.out.println("服务启动成功");
while (true) {
// 非阻塞模式accept方法不会阻塞，否则会阻塞
// NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
SocketChannel socketChannel = serverSocket.accept();
if (socketChannel != null) {
// 如果有客户端进行连接
System.out.println("连接成功");
// 设置SocketChannel为非阻塞
socketChannel.configureBlocking(false);
// 保存客户端连接在List中
channelList.add(socketChannel);
}
// 遍历连接进行数据读取
Iterator<SocketChannel> iterator = channelList.iterator();
while (iterator.hasNext()) {
SocketChannel sc = iterator.next();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024*1024*10);
// 非阻塞模式read方法不会阻塞，否则会阻塞
int len = sc.read(byteBuffer);
if(len > 0){
size += len;
System.out.println(len);
System.out.println("size:"+size);
}
}
}
}
}
fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, size);中发生了一次系统调用
private native long map0(int var1, long var2, long var4) throws IOException;socketChannel.write(mappedByteBuffer);中发生了一次系统调用?
static native int pwrite0(FileDescriptor var0, long var1, int var3, long var4) throws IOException;socketChannel.write(mappedByteBuffer);用户进行需要获取到这个内存映射数据块，放入到socket缓存区中，这块是需要CPU来操作的?
??则：
1、发生了两次系统调用，4次用户态和内核态上下文切换
2、两次DMA copy和一次CPU copy
nio-sendfile
?先来看下用sendfile进行socket通信代码：?
?socket client:?
//默认一次传8M 加-Djdk.nio.enableFastFileTransfer=true
public static void sendFile(Path filename) throws IOException {
long start = System.currentTimeMillis();
//1.打开通道
SocketChannel socketChannel=SocketChannel.open();
//2.连接指定ip和端口号
socketChannel.connect (new InetSocketAddress("127.0.0.1",8888));
try (FileChannel fileChannel = FileChannel.open(filename)) {
long size = fileChannel.size();
fileChannel.transferTo(0,size,socketChannel);
} catch (IOException e) {
e.printStackTrace();
}
socketChannel.close();
long end = System.currentTimeMillis();
System.out.println("sendFile执行耗时："+(end-start));
}??socket server和上述一样：
private native long transferTo0(FileDescriptor var1, long var2, long var4, FileDescriptor var6);?var1:文件描述符，var2:数据的初始偏移量，var4：数据的结束偏移量
var6就是下面socket通道获取的文件描述符
?
?则：
1、发生了一次系统调用，2次用户态和内核态上下文切换
2、两次DMA copy和0次CPU copy
以上都是基于pageCache,pageCache只适合小文件，小文件可以增加命中率，命中成功就无需读取磁盘文件，如果是大文件，则会把pageCahe装满，其他文件进不来，就违背了pageCache设计的初衷，则传输大文件，需要直接IO，AIO中就是用直接IO进行传输的
AIO
??先来看下用AIO进行socket通信代码：?
?socket client:??
public static void aioSend(Path filename) {
try {
// 打开一个SocketChannel通道并获取AsynchronousSocketChannel实例
AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
AsynchronousFileChannel channel = AsynchronousFileChannel.open(filename);
System.out.println(channel.size());
// 连接到服务器并处理连接结果
client.connect(new InetSocketAddress("127.0.0.1", 8888), null, new CompletionHandler<Void, Void>() {
@Override
public void completed(final Void result, final Void attachment) {
System.out.println("成功连接到服务器!");
try {
ByteBuffer buffer = ByteBuffer.allocate(1024*1024*10);
final int[] num = {0};
while (num[0] < channel.size()){
Future<Integer> rresult = channel.read(buffer, num[0]);
Future<Integer> finalRresult = rresult;
num[0] = num[0] + finalRresult.get();
client.write(buffer);
buffer.clear();
System.out.println(result+"-------"+num[0]);
if(num[0] < 0){
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void failed(final Throwable exc, final Void attachment) {
exc.printStackTrace();
}
});
TimeUnit.MINUTES.sleep(Integer.MAX_VALUE);
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}socket server：?
package com.fen.dou;
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.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class AioServer {
public static void main(String[] args) {
try {
final int[] size = {0};
final int port = 8888;
//首先打开一个ServerSocket通道并获取AsynchronousServerSocketChannel实例：
AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
//绑定需要监听的端口到serverSocketChannel:
serverSocketChannel.bind(new InetSocketAddress(port));
//实现一个CompletionHandler回调接口handler，
//之后需要在handler的实现中处理连接请求和监听下一个连接、数据收发，以及通信异常。
CompletionHandler<AsynchronousSocketChannel, Object> handler = new CompletionHandler<AsynchronousSocketChannel,
Object>() {
@Override
public void completed(final AsynchronousSocketChannel result, final Object attachment) {
// 继续监听下一个连接请求
serverSocketChannel.accept(attachment, this);
try {
System.out.println("接受了一个连接：" + result.getRemoteAddress()
.toString());
// 给客户端发送数据并等待发送完成
result.write(ByteBuffer.wrap("From Server:Hello i am server".getBytes()))
.get();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024*1024*10);
Future<Integer> len = result.read(byteBuffer);
if(len.get() > 0){
size[0] += len.get();
System.out.println(len);
}
System.out.println("size:"+ size[0]);
} catch (IOException | InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
@Override
public void failed(final Throwable exc, final Object attachment) {
System.out.println("出错了：" + exc.getMessage());
}
};
serverSocketChannel.accept(null, handler);
// 由于serverSocketChannel.accept(null, handler);是一个异步方法，调用会直接返回，
// 为了让子线程能够有时间处理监听客户端的连接会话，
// 这里通过让主线程休眠一段时间(当然实际开发一般不会这么做)以确保应用程序不会立即退出。
TimeUnit.MINUTES.sleep(Integer.MAX_VALUE);
} catch (InterruptedException | IOException e) {
e.printStackTrace();
}
}
}
? ?Future<Integer> rresult = channel.read(buffer, num[0]);发生一次系统调用?
int var13 = WindowsAsynchronousFileChannelImpl.readFile(WindowsAsynchronousFileChannelImpl.this.handle, var4, this.rem, this.position, var2);client.write(buffer);?发生一次系统调用?
int var12 = WindowsAsynchronousSocketChannelImpl.write0(WindowsAsynchronousSocketChannelImpl.this.handle, this.numBufs, WindowsAsynchronousSocketChannelImpl.this.writeBufferArray, var1);
则：
1、发生了两次系统调用，4次用户态和内核态上下文切换
2、一次DMA 异步copy，一次DMA 同步copy和1次CPU?异步copy
