BIO:同步、阻塞
NIO:同步、非阻塞
AIO:异步、非阻塞
在学习NIO之前,需要大家先了解一些简单的概念:
1.cache(高速缓存)和buffer(缓冲区):
cache缓存区和buffer缓冲区都是临时存储区。
buffer缓冲区主要存在于RAM中,作为CPU暂时存储数据的区域(当计算机和其他设备有不同的速度时,buffer存储着缓冲的数据,这样计算机就可以做其他应用了)
cache缓存区是一种高速存储区域,可以在主存或硬盘灯其他独立存储区域的一部分。
总结:cache高速缓存为硬盘缓存,buffer缓冲区被称为内存缓存。
2.阻塞(Block)和非阻塞(Non-Block):
阻塞和非阻塞是进程在访问数据的时候,数据是否准备就绪的一种处理方式,当数据没有准备的时候
阻塞:往往需要等待缓冲区中的数据准备好过后才处理其他的事情,否则一直等待在哪里。
非阻塞:当我们的进程访问我们的数据缓冲区的时候,如果数据没有准备好则直接返回,不会等待。如果数据已经准备好,也直接放回。
3.同步(Synchronization)和异步(Asynchronous)的方式:
同步和异步都是基于应用程序和操作系统处理IO事件所采用的方式。
比如同步:是应用程序要直接参与IO读写的操作。
异步:所有的IO读写交给操作系统去处理,应用程序只需要等待通知。
同步方式在处理IO事件的时候,必须阻塞在某个方法上面等待我们的IO事件完成(阻塞IO事件或者通过轮询IO事件的方式),对于一部来说,所有的IO读写都交给了操作系统。这个时候,我们可以去做其他的事情,并不需要去完成真正的IO操作,当操作完成IO后会给我们的应用程序一个通知。
同步:阻塞到IO事件,阻塞到read或者write。这个时候我们就完全不能做自己的事情。让读写方法加入到线程里面,然后阻塞线程来实现,对线程的性能开销比较大。
4.BIO(Block IO)于NIO(Non-Block IO)对比:
IO模型 |
IO |
NIO |
方式 |
从硬盘到内存 |
从内存到硬盘 |
通信 |
面向流 |
面向缓冲 |
处理 |
阻塞IO(多线程) |
非阻塞IO(反应堆Reactor) |
触发 |
无 |
选择器(轮询机制) |
5.面向流与面向缓冲:
Java NIO 和 IO 之间第一个最大区别是,IO是面向流的,NIO是面向缓冲区的。Java IO 面向流意味着每次从流中读取一个或多个字节,直至读取所有字节,他们没有被缓存在任何地方。此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。Java NIO 的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。
6.socket(套接字):Socket clinet = new Socket("localhost",8080)
网络上两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为一个socket。
TCP/IP协议帮我们解决能够实现两台主机之间的进程通信,网络层的IP地址可以唯一标识网络中的主机,传输层的协议+端口可以唯一标识主机中的应用程序(进程),这样利用三元组(IP地址、协议、端口)就可以标识网络的进程。
NIO各没款详细解析
一、深入剖析 Buffer
在谈到缓冲区时,我们说缓冲区对象本质上是一个数组,但它其实是一个特殊的数组,缓冲区对象内置了一些机制,
能够跟踪和记录缓冲区的状态变化情况,如果我们使用get()方法从缓冲区获取数据后者使用put()方法把数据写入缓
冲区,都会引起缓冲区状态的变化。
在缓冲区中,最重要的属性有下面三个,它们一起合作完成对缓冲区内部状态的变化跟踪:
position:指定了下一个将要被写入或者读取的元素索引,它的值由get()/put()方法自动更新,在新创建一个Buffer
对象时,position被初始化为0
capacity 数组容量
limit 可操作范围
position 标记/游标 get和put时候到哪个位置 相当于数组索引 index
flip() 把当前缓冲区固定
二、缓冲区的分配
1、分配指定带下的缓冲区
2、包装一个现有的数组 ByteBuffer.wrap(new byte[10])
3、缓冲区的切片 Slice 0<position<limit<capacity 在position和limit之间分成不同的子缓冲区
4、只读缓冲区 buffer.asReadOnlyBuffer() 这个缓冲区的数据不能put()只能get()
5、直接缓冲区 ByteBuffer.allocateDirect(1024) Java程序再怎么分配都是在JVM允许范围内分配(堆栈区),
类似C语言,直接调用C语言模块,最底层。从操作系统中直接分配内存,netty中的零拷贝。
6、内存映射文件I/O,在内存中可读可写,直接持久化硬盘
三、通道 Channel
通道是一个对象,通过它可以读取和写入数据,当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接
写入通道中,相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节,而是将数据从通
道读入缓冲区,再从缓冲区获取这个字节。在NIO中,提供了多种通道对象,而所有的通道对象都实现了Channel接口。
使用NIO读取数据
在前面我们说过,任何时候读取数据,都不是直接从通道读取,而是从通道读取到缓冲区。
所以使用NIO读取数据分为以下三个步骤:
1.从FileInputStream获取Channel
2.创建Buffer
3.将数据从Channel读取到Buffer中
四、反应堆 Reactor
1、阻塞I/O通信模型
加入现在你对阻塞I/O有一定的了解,我们知道阻塞I/O在调用InputStream.read()方法时是阻塞的,它会一直
等到数据到来时(或超时)才会返回;同样,在调用ServerSocket.accept()方法时,也会一直阻塞到有客户端
连接才会返回,每个客户端连接过来后,服务端都会启动一个线程去处理该客户端的请求。
缺点:
a.当客户端多时,会创建大量的处理线程。而且每个线程都要占用栈空间和cpu时间
b.阻塞可能带来频繁的上下文切换,而且大部分上下文切换是可能无意义的
2、Java NIO原理及通信模型
Java NIO是在jdk 1.4开始使用的,称为新的I/O或者是非阻塞式I/O
工作原理:
a.由一个专门的线程来处理所有的IO时间,并负责分发。
b.事件驱动机制:事件到的时候触发,而不是同步的去监视事件
c.线程通讯:线程之间通过wait,notify等方式通讯,保证每次上下文切换都是有意义的,减少不必要的线程切换
(每个线程的处理流程大概都是读取数据、解码、计算处理、编码、发送响应)
五、选择器 Selector
传统的Server/Clinet模式会基于trp(Thread pre Request),服务器会为每个客户端请求建立一个线程,由该线程单独
负责处理一个客户端请求。这种模式带来的一个问题是线程数据的剧增,大量的线程会增大服务器的开销。大多数的实现
为了避免这个问题,都采用了线程池模型,并设置线程池线程的最大数量,这又带来了新的问题,如果线程池中有200个线
程,而又200个用户都在进行大文件下载,会导致201个用户的请求无法及时处理,即便第201个用户只想请求一个几KB大小的页面。
NIO中非阻塞I/O采用了基于Reactor模式的工作方式,I/O调用不会被阻塞,相反是注册感兴趣的特定I/O事件,如可读数据
到达,新的套接字连接等等,在发生特定事件时,系统再通知我们。NIO中实现非阻塞I/O的核心对象就是Selector,Selector
就是注册各种I/O事件池,而且当那些事情发生时,就是这个对象告诉我们所发生的事件。
NIOServer代码:
package com.sinosoft.study.nio.demo;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;
public class NIOServer {
private int port = 8080;
private Selector selector;
public NIOServer(int port){
try{
this.port = port;
// ServerSocketChannel是一个可以监听新进来的TCP连接的通道,就像标准IO中的ServerSocket一样
// 获得一个ServerSocket通道
ServerSocketChannel server = ServerSocketChannel.open();
// 默认为阻塞,手动改为非阻塞
server.configureBlocking(false);
// 将该通道对于的 ServerSocket 绑定到 port端口号
server.socket().bind(new InetSocketAddress(port));
// 获得一个通道选择器
selector = Selector.open();
/*
* 将通道选择器和该通道绑定,并为该通道注册selectionKey.OP_ACCEPT事件
* 注册该事件后,当事件到达的时候,selector.select()会返回,
* 如果事件没有到达selector.select()会一直阻塞
*/
server.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务器准备就绪,监听端口是:"+ this.port);
}catch(Exception e){
e.printStackTrace();
}
}
public void listen(){
try {
System.out.println("start server");
// 轮询
while (true) {
// 当注册事件到达时,方法返回,否则该方法会一直阻塞
int wait = this.selector.select();
if(wait == 0){ continue;}
// 获得selector中选中的迭代器,选中注册的事件
Set<SelectionKey> keys = this.selector.selectedKeys();
Iterator<SelectionKey> i = keys.iterator();
while(i.hasNext()){
SelectionKey key = i.next();
process(key);
i.remove();
}
}
}catch (Exception e){
e.printStackTrace();
}
}
public void process(SelectionKey key) throws Exception {
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 客户端请求连接事件
if(key.isAcceptable()){
ServerSocketChannel server = (ServerSocketChannel) key.channel();
// 获得和客户端连接的通道
SocketChannel client = server.accept();
client.configureBlocking(false);
// 在客户端连接成功之后,为了可以接收到客户端的信息,需要给通道设置读的权限
client.register(selector,SelectionKey.OP_READ);
}else if(key.isReadable()){
SocketChannel client = (SocketChannel) key.channel();
int len = client.read(buffer);
if(len > 0){
buffer.flip();
String content = new String(buffer.array(),0,len);
System.out.println(content);
client.register(selector,SelectionKey.OP_WRITE);
}
buffer.clear();
}else if(key.isWritable()){
SocketChannel client = (SocketChannel) key.channel();
buffer = buffer.wrap("Hello Wold".getBytes());
client.read(buffer);
}
}
public static void main(String[] args) {
new NIOServer(8080).listen();
}
}
BIO客户端代码:
package com.sinosoft.study.bio;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.UUID;
public class BIOClient {
public static void main(String[] args) throws UnknownHostException, IOException{
// 获取一个Socket通道
Socket client = new Socket("localhost",8080);
// 输入流通道打开
OutputStream os = client.getOutputStream();
String uuid = UUID.randomUUID().toString();
System.out.println("要输出的内容为:" + uuid);
os.write(uuid.getBytes());
os.close();
client.close();
}
}
BIO服务端代码:
package com.sinosoft.study.bio;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class BIOServer {
ServerSocket server;
// 服务器
public BIOServer(int port){
try{
// 把Socket服务端启动
server = new ServerSocket(port);
System.out.println("BIO服务已启动,监听的端口号是:" + port);
}catch(IOException e){
e.printStackTrace();
}
}
/**
* @Description: 开始监听,并处理逻辑
* @Param:
* @return:
* @Author: Mr.WangYu
* @Date: 2018/11/11
* @Time: 14:29
*/
public void listener() throws IOException{
// 循环监听
while(true){
// 等待客户端的连接,阻塞方法
Socket client = server.accept();
InputStream is = client.getInputStream();
byte []b = new byte[1024];
int num = is.read(b);
if (num > 0){
String msg = new String(b,0,num);
System.out.println("收到:" + msg);
}
}
}
public static void main(String[] args) throws IOException{
new BIOServer(8080).listener();
}
}
赠品:AIO服务端代码
package com.sinosoft.study.aio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
public class AIOServer {
private int port = 8080;
public AIOServer(int port){
this.port = port;
}
public void listen(){
try {
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open();
server.bind(new InetSocketAddress(this.port));
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
@Override
public void completed(AsynchronousSocketChannel client, Object attachment) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
client.read(buffer);
buffer.flip();
System.out.println("111111111111");
System.out.println(new String(buffer.array()));
}
@Override
public void failed(Throwable exc, Object attachment) {
}
});
}catch (Exception e){
e.printStackTrace();
}
try {
Thread.sleep(Integer.MAX_VALUE);
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) {
new AIOServer(8080).listen();
}
}