一、五种IO类型
1、阻塞IO
用户进程一直等待数据准备好，在复制完成之前都是阻塞的
2、非阻塞IO
用户进程需要不断轮询查看是否数据准备好
优化了提升并发连接数量，但是每一个请求都需要创建一个socket建立连接，每个线程都需要去遍历轮询，导致cpu的消耗，直到数据返回成功
3、IO复用
（1）select/poll
单个线程可以处理多个网络连接。相对于BIO多了一步，注册到selector的过程，进程被selector函数阻塞。
select单个进程所能打开的fd()【就是文件描述符，linux内把所有的外部设备都看成一个文件操作】，对于每一个文件的读写操作都会调用内核提供的系统命令来返回给fd，对于socket的读写也会返回一个fd，所以放fd的时候，说明数据是可读或者是可写。
所以这个模型在单进程里，操作的连接数默认是1024，可以修改，但是会带来网络性能的下降，因为会去加大轮询次数，带来网络延迟，因为只有少数连接处于活跃状态，而每次轮询是查询所有的连接。
jdk1.6之前是使用这种模型
（2）epoll
jdk1.6后使用此模型。解决select-poll的缺陷
- 对单个进程锁打开的连接数没有限制（连接需要占用内存，1TB大概10w个连接）
- 利用每个fd上的callback函数来实现异步回调，省去了轮询的开销
- mmap：通过内核和用户空间映射同一块内存空间，来减少内存复制
4、异步IO
二、NIO
1、了解
基于通道和缓冲区操作的：
- 通道：一个新的原始IO
- 缓冲支持：负责数据存储和传输的缓冲区
- 具体：数据从通道读取到缓冲，数据从缓冲区写入通道
非阻塞的：
- 针对网络的，当线程从通道读取数据到缓冲区，线程依然可以进行其他事情（1.6以后epoll模型）
选择器：
- 用于监听多个通道的事件，例如链接打开、数据到达
- 单个线程可以监听多个数据通道
2、Channel
FileChannel：从文件中读写数据（不适合Selector，因为不能非阻塞）
DatagramChannel：通过UDP协议读写网络中的数据
SocketChannel：通过TCP协议读写网络中的数据
ServerSocketChannel：监听一个TCP连接，对于每一个新的客户端连接都会创建一个SocketChannel。
3、Buffer
buffer是一个对象，包含需要写入或者刚读出的数据，常用的缓冲区类型是ByteBuffer
public class aaa {
public static void main(String[] args) throws IOException {
try {
FileInputStream fis = new FileInputStream(new File("D:/test.txt"));
FileOutputStream fos = new FileOutputStream(new File("D:/test.txt"));
FileChannel fin = fis.getChannel();
FileChannel fout = fos.getChannel();
//初始化一个缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
//读取数据到缓冲区
fin.read(buffer);
//从读转化为写
buffer.flip();
fout.write(buffer);
//重置缓冲区
buffer.clear();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}4、IO和NIO的区别
| 类型 | 操作区域 | 处理数据 | IO |
| IO | 面向最初的数据源 | 每次读取时=读取所有字节或字符，无缓存 无法前后移动读取流中的数据 | 当一个线程在读或者写的时候，当数据被完全读取/写入之后，并且数据未准备好时，线程不能做其他任务，只能一直等待。 当线程处于活跃状态并且外部未准备好时，阻塞。 |
| NIO | 面相缓冲区 | 先将数据读取到缓冲区 可在缓冲区前后移动数据流 | 当一个线程向某个通道发送请求时，当数据被完全读取/写入，并且数据未准备好时，线程可以操作其他任务，直到数据准备后再切换回原通道，继续读写，也就是selector的使用。 外部准备好时才唤醒线程，则不会阻塞。 |
5、缓冲区的内部细节
缓冲区本质是一块可以写入数据，以及从中读取数据的内存，实际上也是一个byte[]数据，只是在NIO中被封装成了NIO Buffer对象，并提供了一组方法来访问这个内存块。
- capacity：容量
- position：位置。读是跟踪从缓冲区读取了多少数据；写是数据放入数组哪个位置；
- limit：写是还有多少数据取出来写到通道；读是还有多少空间可以放出去；
例如：写入
初始话时，capacity是8，就是一个8长度的格子，当写入“hello”的时候，就是ficn.reds("hello);时,postion和limit都会指向4（从0开始），当flip()时，position指向0，limit是4，0-4就是要写入的字符，最后write()写入。
6、零拷贝的原理
IO流程：内核给磁盘发送命令需要读取磁盘的数据，在DMA的控制下，把磁盘上的数据读入到内核缓冲区，内核把数据从内核缓冲区复制到用户缓冲区。用户缓冲区再将数据拷贝到Socket buffer(也是内核)，最后发送到网卡缓冲区，四个步骤。
设计到一个用户态到内核态的切换，影响cpu的性能。
从内核态到用户缓冲区没有用，为什么要设计呢
为了提升IO性能，假设应用程序进行读，内核缓冲区对于读相当于一个缓冲空间，当用户只读取一小部分数据的时候，但是内核从磁盘会读取一块数据，下次用户再读其他的数据的时候，在内核缓冲区已经存在就不需要再去磁盘获取，从这个角度是提升了性能的。
使用内存映射缓存mmap，通过内核和用户空间映射同一块内存空间，来减少内存复制。
零拷贝就是减少拷贝次数，减少内核态和用户态之间的数据的复制，提升IO性能。
public class aaa {
public static void main(String[] args) throws IOException {
try {
FileChannel in = FileChannel.open(Paths.get("D:/logo.png"), StandardOpenOption.READ);
FileChannel out = FileChannel.open(Paths.get("D:/logo_cp.png"), StandardOpenOption.READ, StandardOpenOption.CREATE, StandardOpenOption.WRITE);
MappedByteBuffer inMap = in.map(FileChannel.MapMode.READ_ONLY, 0, in.size());
MappedByteBuffer outMap = in.map(FileChannel.MapMode.READ_WRITE, 0, in.size());
byte[] bytes = new byte[inMap.limit()];
inMap.get(bytes);
outMap.put(bytes);
in.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
public class ccc {
public static void main(String[] args) {
try {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 9090));
FileChannel channel = new FileInputStream("D:/1.txt").getChannel();
int position = 0;
long size = channel.size();
while (size > 0) {
long tf = channel.transferTo(position, size, socketChannel);
if (tf > 0) {
position += tf;
size = tf;
}
}
socketChannel.close();
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public class ddd {
public static void main(String[] args) {
try {
ServerSocketChannel channel = ServerSocketChannel.open();
channel.socket().bind(new InetSocketAddress(9090));
SocketChannel accept = channel.accept();
ByteBuffer allocate = ByteBuffer.allocate(1024);
int r = 0;
FileChannel fileChannel = new FileOutputStream("D:/text_cp.txt").getChannel();
while (r != -1){
r = accept.read(allocate);
allocate.flip();
fileChannel.write(allocate);
allocate.clear();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
7、SocketChannel和ServerSocketChannel
服务端
public class aaa {
public static void main(String[] args) throws IOException {
try {
//支持两种模式：阻塞、非阻塞
ServerSocketChannel open = ServerSocketChannel.open();
open.configureBlocking(false);
//绑定端口号
open.socket().bind(new InetSocketAddress(9090));
while (true) {
SocketChannel accept = open.accept();
//存在连接
if (accept != null) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
accept.read(buffer);
System.out.println(new String(buffer.array()));
//再把消息写回到客户端
Thread.sleep(10000);
buffer.filp();
accept.write(buffer);
} else {
Thread.sleep(1000);
System.out.println("无客户端连接");
}
}
} catch (FileNotFoundException | InterruptedException e) {
e.printStackTrace();
}
}
}
客户端
public class aaa {
public static void main(String[] args) throws IOException {
try {
SocketChannel open = SocketChannel.open();
//把客户端设置为非阻塞，在非阻塞模式下，不一定是等到连接建立之后再往下执行
open.configureBlocking(false);
open.connect(new InetSocketAddress("localhost", 9090));
if(open.isConnectionPending()) {
open.finishConnect();
}
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.flip();
open.write(buffer);
//读取服务端返回的数据
buffer.clear();
//非阻塞模式，这里不阻塞
int r = open.read(buffer);
if(r > 0) {
System.out.println("收到服务端的消息" + new String(buffer.array()));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
8、选择器Selector
一个单独的线程可以管理多个channel，从而管理多个网络连接。
public class aaa {
static Selector selector;
public static void main(String[] args) throws IOException {
//创建一个多路复用器
Selector selector = Selector.open();
ServerSocketChannel channel = ServerSocketChannel.open();
//连接的非阻塞
channel.configureBlocking(false);
channel.socket().bind(new InetSocketAddress(9090));
//监听连接事件,会返回一个SelectionKey，通道的唯一标识
channel.register(selector, SelectionKey.OP_ACCEPT);
//轮询
while (true) {
//阻塞，所有注册到复用器上事件
selector.select();
//一旦某个channel准备就绪，就返回他们的key
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
//一定是已经就绪的通道
SelectionKey next = iterator.next();
//拿到通道后，可以处理了，避免重复处理
iterator.remove();
if(next.isAcceptable()){
//连接事件
HandleAccept(next);
}else if(next.isReadable()){
//读事件
HandleRead(next);
}
}
}
}
private static void HandleAccept(SelectionKey selectionKey) throws IOException {
ServerSocketChannel serverSocketChannel = (ServerSocketChannel)selectionKey.channel();
SocketChannel accept = serverSocketChannel.accept();
//IO的非阻塞
accept.configureBlocking(false);
accept.write(ByteBuffer.wrap("Server write".getBytes()));
//注册的是accept的读事件
accept.register(selector, SelectionKey.OP_ACCEPT);
}
private static void HandleRead(SelectionKey selectionKey) throws IOException {
SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
socketChannel.read(buffer);
System.out.println("Server receive msg: " + new String(buffer.array()));
}
}
public class bbb {
static Selector selector;
public static void main(String[] args) {
try {
selector = Selector.open();
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("localhost", 9090));
socketChannel.register(selector, SelectionKey.OP_CONNECT);
while (true) {
selector.select();
Set<SelectionKey> selectionKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey next = iterator.next();
iterator.remove();
if(next.isConnectable()){
//连接事件
HandleConnect(next);
}else if(next.isReadable()){
//读事件
HandleRead(next);
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
private static void HandleConnect(SelectionKey selectionKey) throws IOException {
SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
if(socketChannel.isConnectionPending()){
socketChannel.finishConnect();
}
socketChannel.configureBlocking(false);
socketChannel.write(ByteBuffer.wrap("Client receive".getBytes()));
socketChannel.register(selector, SelectionKey.OP_READ);
}
//读取服务端返回的数据
private static void HandleRead(SelectionKey selectionKey) throws IOException {
SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
socketChannel.read(buffer);
System.out.println("Client receive msg: " + new String(buffer.array()));
}
}
9、BIO\NIO\AIO的区别
| BIO | NIO | AIO | |
| 阻塞 | 阻塞：一个线程执行IO操作会被阻塞 | 非阻塞：线程可以同时处理多个IO请求 | 非阻塞 |
| 同步 | 同步：需要等待IO操作完成后才能继续执行 | 异步：轮询方式=channel+buffer+selector | 回调机制 |
| 处理 | 面向流 | 缓冲区 | 面向事件 |
| 并发 | 低，需要创建大量线程 | 通过单线程或少量线程处理 | 同左 |
| 场景 | 连接数少且吞吐量不高 | 连接数较多但请求量较小 | 高并发 |
