java BIO NIO AIO
BIO、NIO、AIO介绍
在Java的软件设计开发中,通信架构是不可避免的,我们在进行不同系统或者不同进程之间的数据交互,或者在高并发下的通信场景下都需要用到网络通信相关的技术,对于一些经验丰富的程序员来说,Java早期的网络通信架构存在一些缺陷,最令人恼火的是基于性能低下的同步阻塞式的I/O通信(BIO),随着互联网开发下通信性能的高要求,Java开始支持了非阻塞式的I/O通信技术(NIO)
通信技术整体解决的问题
- 局域网内的通信要求。
- 多系统间的底层消息传递机制。
- 高并发下,大数据量的通信场景需要。
Java BIO
同步并阻塞(传统阻塞型),服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器
端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销
Java NIO
Java NIO : 同步非阻塞,服务器实现模式为一个线程处理多个请求(连接),即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有 I/O 请求就进行处理
- NIO 相关类都被放在 java.nio 包及子包下,并且对原 java.io 包中的很多类进行改写。
- NIO 有三大核心部分:Buffer( 缓冲区),Channel( 通道) , Selector( 选择器或者多路复用器)
- NIO 的非阻塞模式:使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。
- 通俗理解:NIO 是可以做到用一个线程来处理多个操作的。假设有 1000 个请求过来,根据实际情况,可以分配20 或者 80个线程来处理。不像之前的阻塞 IO 那样,非得分配 1000 个。
- NIO中的selector循环监控channel中的读写就绪事件,channel不会阻塞
NIO 和 BIO 的比较
- BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多, BIO 是阻塞的,NIO 则是非阻塞的
- BIO 基于字节流和字符流进行操作,而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道
BIO | NIO |
面向流(Stream) | 面向缓冲区(Buffer) |
阻塞IO(Blocking IO) | 非阻塞(Non Blocking IO) |
选择器(Selectors) |
Buffer缓冲区
缓冲区本质上是一块可以写入数据,然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象,并提供了一组方法,用来方便的访问该块内存。相比较直接对数组的操作,Buffer API更加容易操作和管理。
Channel(通道)
Java NIO的通道类似流,但又有些不同:既可以从通道中读取数据,又可以写数据到通道。但流的(input或output)读写通常是单向的。 通道可以非阻塞读取和写入通道,通道可以支持读取或写入缓冲区,也支持异步地读写。
Selector选择器
Selector是 一个Java NIO组件,可以能够检查一个或多个 NIO 通道,并确定哪些通道已经准备好进行读取或写入。这样,一个单独的线程可以管理多个channel,从而管理多个网络连接,提高效率
* 每个 channel 都会对应一个 Buffer
* 一个线程对应Selector , 一个Selector对应多个 channel(连接)
* 程序切换到哪个 channel 是由事件决定的
* Selector 会根据不同的事件,在各个通道上切换
* Buffer 就是一个内存块 , 底层是一个数组
* 数据的读取写入是通过 Buffer完成的 , BIO 中要么是输入流,或者是输出流, 不能双向,但是 NIO 的 Buffer 是可以读也可以写。
NIO核心一:缓冲区(Buffer)
一个用于特定基本数据类 型的容器。由 java.nio 包定义的,所有缓冲区 都是 Buffer 抽象类的子类.。Java NIO 中的 Buffer 主要用于与 NIO 通道进行 交互,数据是从通道读入缓冲区,从缓冲区写入通道中的
Buffer 类及其子类
Buffer 就像一个数组,可以保存多个相同类型的数据。根据数据类型不同 ,有以下 Buffer 常用子类:
* ByteBuffer
* CharBuffer
* ShortBuffer
* IntBuffer
* LongBuffer
* FloatBuffer
* DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据,只是各自管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象:
static XxxBuffer allocate(int capacity) 创建一个容量为capacity 的 XxxBuffer 对象 分配内存
Buffer 中的重要概念
容量 (capacity) :作为一个内存块,Buffer具有一定的固定大小,也称为"容量",缓冲区容量不能为负,并且创建后不能更改。
限制 (limit):表示缓冲区中可以操作数据的大小(limit 后数据不能进行读写)。缓冲区的限制不能为负,并且不能大于其容量。 写入模式,限制等于buffer的容量。读取模式下,limit等于写入的数据量。
位置 (position):下一个要读取或写入的数据的索引。缓冲区的位置不能为 负,并且不能大于其限制
标记 (mark)与重置 (reset):标记是一个索引,通过 Buffer 中的 mark() 方法 指定 Buffer 中一个特定的 position,之后可以通过调用 reset() 方法恢复到这 个 position.
标记、位置、限制、容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity
Buffer常见方法
-
-
Buffer clear() 清空缓冲区并返回对缓冲区的引用
-
Buffer flip() 为将缓冲区的界限设置为当前位置,并将当前位置充值为 0 设置为读数据
-
int capacity() 返回 Buffer 的 capacity 大小
-
boolean hasRemaining() 判断缓冲区中是否还有元素
-
int limit() 返回 Buffer 的界限(limit) 的位置
-
Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
-
Buffer mark() 对缓冲区设置标记
-
int position() 返回缓冲区的当前位置 position
-
Buffer position(int n) 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
-
int remaining() 返回 position 和 limit 之间的元素个数
-
Buffer reset() 将位置 position 转到以前设置的 mark 所在的位置
-
Buffer rewind() 将位置设为为 0, 取消设置的 mark
缓冲区的数据操作
-
Buffer 所有子类提供了两个用于数据操作的方法:get()put() 方法
-
取获取 Buffer中的数据
-
get() :读取单个字节
-
get(byte[] dst):批量读取多个字节到 dst 中
-
get(int index):读取指定索引位置的字节(不会移动 position)
-
-
放到 入数据到 Buffer 中 中
-
put(byte b):将给定单个字节写入缓冲区的当前位置
-
put(byte[] src):将 src 中的字节写入缓冲区的当前位置
-
put(int index, byte b):将指定字节写入缓冲区的索引位置(不会移动 position)
使用Buffer读写数据一般遵循以下四个步骤:
- 写入数据到Buffer
- 调用flip()方法,转换为读取模式
- 从Buffer中读取数据
- 调用buffer.clear()方法或者buffer.compact()方法清除缓冲区,转换为写模式
案例演示
-
public class TestBuffer {
-
-
public void test3(){
-
//分配直接缓冲区
-
ByteBuffer buf = ByteBuffer.allocateDirect(1024);
-
System.out.println(buf.isDirect());
-
}
-
-
-
public void test2(){
-
String str = "ieiehma";
-
-
ByteBuffer buf = ByteBuffer.allocate(1024);
-
-
buf.put(str.getBytes());
-
-
buf.flip();
-
-
byte[] dst = new byte[buf.limit()];
-
buf.get(dst, 0, 2);
-
System.out.println(new String(dst, 0, 2));
-
System.out.println(buf.position());
-
-
//mark() : 标记
-
buf.mark();
-
-
buf.get(dst, 2, 2);
-
System.out.println(new String(dst, 2, 2));
-
System.out.println(buf.position());
-
-
//reset() : 恢复到 mark 的位置
-
buf.reset();
-
System.out.println(buf.position());
-
-
//判断缓冲区中是否还有剩余数据
-
if(buf.hasRemaining()){
-
//获取缓冲区中可以操作的数量
-
System.out.println(buf.remaining());
-
}
-
}
-
-
-
public void test1(){
-
String str = "itheima";
-
//1. 分配一个指定大小的缓冲区
-
ByteBuffer buf = ByteBuffer.allocate(1024);
-
System.out.println("-----------------allocate()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
-
//2. 利用 put() 存入数据到缓冲区中
-
buf.put(str.getBytes());
-
System.out.println("-----------------put()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
-
//3. 切换读取数据模式
-
buf.flip();
-
System.out.println("-----------------flip()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
-
//4. 利用 get() 读取缓冲区中的数据
-
byte[] dst = new byte[buf.limit()];
-
buf.get(dst);
-
System.out.println(new String(dst, 0, dst.length));
-
-
System.out.println("-----------------get()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
//5. rewind() : 可重复读
-
buf.rewind();
-
System.out.println("-----------------rewind()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
-
//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在,但是处于“被遗忘”状态
-
buf.clear();
-
System.out.println("-----------------clear()----------------");
-
System.out.println(buf.position());
-
System.out.println(buf.limit());
-
System.out.println(buf.capacity());
-
System.out.println((char)buf.get());
-
-
}
-
-
}
直接与非直接缓冲区
根据官方文档的描述:
byte byffer可以是两种类型,一种是基于直接内存(也就是非堆内存);另一种是非直接内存(也就是堆内存)。对于直接内存来说,JVM将会在IO操作上具有更高的性能,因为它直接作用于本地系统的IO操作。而非直接内存,也就是堆内存中的数据,如果要作IO操作,会先从本进程内存复制到直接内存,再利用本地IO处理。
从数据流的角度,非直接内存是下面这样的作用链:
本地IO-->直接内存-->非直接内存-->直接内存-->本地IO而直接内存是:
本地IO-->直接内存-->本地IO
很明显,在做IO处理时,比如网络发送大量数据时,直接内存会具有更高的效率。直接内存使用allocateDirect创建,但是它比申请普通的堆内存需要耗费更高的性能。不过,这部分的数据是在JVM之外的,因此它不会占用应用的内存。所以呢,当你有很大的数据要缓存,并且它的生命周期又很长,那么就比较适合使用直接内存。只是一般来说,如果不是能带来很明显的性能提升,还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。
NIO核心二:通道(Channel)
通道Channe概述
通道(Channel):由 java.nio.channels 包定义 的。Channel 表示 IO 源与目标打开的连接。是一个管道,与流最大的不同就是,通道可以读写数据,而流是单向的, Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据,Channel 只能与 Buffer 进行交互。
NIO 的通道类似于流,但有些区别如下:
- 通道可以同时进行读写,而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据,也可以写数据到缓冲:
BIO 中的 stream 是单向的,例如 FileInputStream 对象只能进行读取数据的操作,而 NIO 中的通道(Channel)是双向的,可以读操作,也可以写操作。
Channel 在 NIO 中是一个接口
public interface Channel extends Closeable{}
常用的Channel实现类
-
FileChannel:用于读取、写入、映射和操作文件的通道。
-
DatagramChannel:通过 UDP 读写网络中的数据通道。
-
SocketChannel:通过 TCP 读写网络中的数据。
-
ServerSocketChannel:可以监听新进来的 TCP 连接,对每一个新进来的连接都会创建一个 SocketChannel。
FileChannel 类
获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下:
-
FileInputStream
-
FileOutputStream
-
RandomAccessFile
-
DatagramSocket
-
Socket
-
ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道
FileChannel的常用方法
-
int read(ByteBuffer dst) 从 从 Channel 到 中读取数据到 ByteBuffer
-
long read(ByteBuffer[] dsts) 将 将 Channel 到 中的数据“分散”到 ByteBuffer[]
-
int write(ByteBuffer src) 将 将 ByteBuffer 到 中的数据写入到 Channel
-
long write(ByteBuffer[] srcs) 将 将 ByteBuffer[] 到 中的数据“聚集”到 Channel
-
long position() 返回此通道的文件位置
-
FileChannel position(long p) 设置此通道的文件位置
-
long size() 返回此通道的文件的当前大小
-
FileChannel truncate(long s) 将此通道的文件截取为给定大小
-
void force(boolean metaData) 强制将所有对此通道的文件更新写入到存储设备中
使用Buffer完成文件复制
-
-
public void copy() throws Exception {
-
// 源文件
-
File srcFile = new File("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\壁纸.jpg");
-
File destFile = new File("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\壁纸new.jpg");
-
// 得到一个字节字节输入流
-
FileInputStream fis = new FileInputStream(srcFile);
-
// 得到一个字节输出流
-
FileOutputStream fos = new FileOutputStream(destFile);
-
// 得到的是文件通道
-
FileChannel isChannel = fis.getChannel();
-
FileChannel osChannel = fos.getChannel();
-
// 分配缓冲区
-
ByteBuffer buffer = ByteBuffer.allocate(1024);
-
while(true){
-
// 必须先清空缓冲然后再写入数据到缓冲区
-
buffer.clear();
-
// 开始读取一次数据
-
int flag = isChannel.read(buffer);
-
if(flag == -1){
-
break;
-
}
-
// 已经读取了数据 ,把缓冲区的模式切换成可读模式
-
buffer.flip();
-
// 把数据写出到
-
osChannel.write(buffer);
-
}
-
isChannel.close();
-
osChannel.close();
-
System.out.println("复制完成!");
-
}
分散 (Scatter) 和聚集 (Gather)
分散读取(Scatter ):是指把Channel通道的数据读入到多个缓冲区中去
聚集写入(Gathering )是指将多个 Buffer 中的数据“聚集”到 Channel。
-
//分散和聚集
-
-
public void test() throws IOException{
-
RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
-
//1. 获取通道
-
FileChannel channel1 = raf1.getChannel();
-
-
//2. 分配指定大小的缓冲区
-
ByteBuffer buf1 = ByteBuffer.allocate(100);
-
ByteBuffer buf2 = ByteBuffer.allocate(1024);
-
-
//3. 分散读取
-
ByteBuffer[] bufs = {buf1, buf2};
-
channel1.read(bufs);
-
-
for (ByteBuffer byteBuffer : bufs) {
-
byteBuffer.flip();
-
}
-
-
System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
-
System.out.println("-----------------");
-
System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
-
-
//4. 聚集写入
-
RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
-
FileChannel channel2 = raf2.getChannel();
-
-
channel2.write(bufs);
-
}
零拷贝
首先零拷贝不代表不拷贝,只是减少拷贝次数,java代码发生网络io,交互的是操作系统,会发生用户态到内核态的转变,然后内核复制数据到用户缓冲区,用户处理在复制到socket缓冲区,零拷贝的意义就在于:减少用户态到内核态切换次数,减少数据复制次数
以下两个方法均使用了零拷贝
transferFrom() 从目标通道中去复制原通道数据
transferTo() 把原通道数据复制到目标通道
NIO核心三:选择器(Selector)
选择器(Selector) 是 SelectableChannle 对象的多路复用器,Selector 可以同时监控多个 SelectableChannel 的 IO 状况,也就是说,利用 Selector可使一个单独的线程管理多个 Channel。Selector 是非阻塞 IO 的核心
Java 的 NIO,用非阻塞的 IO 方式。可以用一个线程,处理多个的客户端连接,就会使用到 Selector(选择器),Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个 Selector,如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道,也就是管理多个连接和请求。只有在 连接/通道 真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程 避免了多线程之间的上下文切换导致的开销
选择器(Selector)的应用
创建 Selector :通过调用 Selector.open() 方法创建一个 Selector。
Selector selector = Selector.open();
向选择器注册通道:
SelectableChannel.register(Selector sel, int ops)
-
//1. 获取通道
-
ServerSocketChannel ssChannel = ServerSocketChannel.open();
-
//2. 切换非阻塞模式
-
ssChannel.configureBlocking(false);
-
//3. 绑定连接
-
ssChannel.bind(new InetSocketAddress(9898));
-
//4. 获取选择器
-
Selector selector = Selector.open();
-
//5. 将通道注册到选择器上, 并且指定“监听接收事件”
-
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
当调用 register(Selector sel, int ops) 将通道注册选择器时,选择器对通道的监听事件,需要通过第二个参数 ops 指定。可以监听的事件类型(用 可使用 SelectionKey 的四个常量 表示):
- 读 : SelectionKey.OP_READ
- 写 : SelectionKey.OP_WRITE
- 连接 : SelectionKey.OP_CONNECT
- 接收 : SelectionKey.OP_ACCEPT
- 若注册时不止监听一个事件,则可以使用“位或”操作符连接。
- channel.accept() 与客户端连接事件,channel.read()会阻塞,nio中可以设置阻塞模式为false
- selector.select()监听事件也是阻塞的,通过selector.wakeup(),或者有读写就绪事件时可以向下运行
int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE
客户端实现
-
public class Client {
-
-
public static void main(String[] args) throws Exception {
-
//1. 获取通道
-
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
-
//2. 切换非阻塞模式
-
sChannel.configureBlocking(false);
-
//3. 分配指定大小的缓冲区
-
ByteBuffer buf = ByteBuffer.allocate(1024);
-
//4. 发送数据给服务端
-
Scanner scan = new Scanner(System.in);
-
while(scan.hasNext()){
-
String str = scan.nextLine();
-
buf.put((new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(System.currentTimeMillis())
-
"\n" str).getBytes());
-
buf.flip();
-
sChannel.write(buf);
-
buf.clear();
-
}
-
//5. 关闭通道
-
sChannel.close();
-
}
-
}
服务端实现
-
public class Server {
-
-
//BACK_LOG影响的accept队列大小
-
public static final int BACK_LOG = 1024;
-
-
public static void main(String[] args) throws Exception {
-
ServerSocketChannel serverChannel = ServerSocketChannel.open();
-
//设置非阻塞
-
serverChannel.configureBlocking(false);
-
//绑定端口,在服务端监听
-
serverChannel.bind(new InetSocketAddress("127.0.0.1", 9999), BACK_LOG);
-
//serverChannel.socket().bind(new InetSocketAddress("127.0.0.1",9999), BACK_LOG);
-
//创建Selector对象
-
Selector selector = Selector.open();
-
//ServerSocketChannel注册到Selector,并监听连接事件
-
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
-
//循环等待客户端连接
-
for (; ; ) {
-
// 阻塞等待事件就绪,可以传入等待事件
-
if (selector.select(1000) == 0) {
-
System.out.println("服务器等待了1秒,无连接");
-
continue;
-
}
-
//有事件发生加入集合,获取迭代器,读取通道缓冲区数据
-
Set<SelectionKey> selectionKeys = selector.selectedKeys();
-
Iterator<SelectionKey> iterator = selectionKeys.iterator();
-
while (iterator.hasNext()) {
-
SelectionKey key = iterator.next();
-
-
//如果是OP_ACCEPT,有新的客户端连接
-
if (key.isAcceptable()) {
-
SocketChannel channel = serverChannel.accept();
-
System.out.println("连接成功,SocketChannel:" channel.hashCode());
-
channel.configureBlocking(false);
-
//关联buffer
-
channel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
-
}
-
//判断是否可读事件
-
if (key.isReadable()) {
-
SocketChannel channel = (SocketChannel) key.channel();
-
//获取buffer
-
ByteBuffer buffer = (ByteBuffer) key.attachment();
-
//把通道数据放入缓冲区
-
channel.read(buffer);
-
}
-
//移除Selection,必须移除,否则会有重复运行发生
-
iterator.remove();
-
}
-
}
-
}
-
}
NIO多线程优化
单线程下的io并不完美,所以我们主线程用来等待连接,worker线程实现读写,线程通信可以使用队列加入Runable任务,这里不在赘述
java AIO
Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
BIO | NIO | AIO |
Socket | SocketChannel | AsynchronousSocketChannel |
ServerSocket | ServerSocketChannel | AsynchronousServerSocketChannel |
与NIO不同,当进行读写操作时,只须直接调用API的read或write方法即可, 这两种方法均为异步的,对于读操作而言,当有流可读取时,操作系统会将可读的流传入read方法的缓冲区,对于写操作而言,当操作系统将write方法传递的流写入完毕时,操作系统主动通知应用程序
即可以理解为,read/write方法都是异步的,完成后会主动调用回调函数。在JDK1.7中,这部分内容被称作NIO.2,主要在Java.nio.channels包下增加了下面四个异步通道:
-
AsynchronousSocketChannel
-
AsynchronousServerSocketChannel
-
AsynchronousFileChannel
-
AsynchronousDatagramChannel
Reactor(反应器)模型
从线程处理方面优化NIO模型的变化
单线程Reactor模型
最传统模型
多线程的 Reactor 模型
多哥线程和selector处理客户端请求
多线程主从 Reactor 模型
总结
BIO、NIO、AIO:
- Java BIO : 同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。
- Java NIO : 同步非阻塞,服务器实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
- Java AIO(NIO.2) : 异步非阻塞,服务器实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。
BIO、NIO、AIO适用场景分析:
- BIO方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4以前的唯一选择,但程序直观简单易理解。
- NIO方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,并发局限于应用中,编程比较复杂,JDK1.4开始支持。
- AIO方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用OS参与并发操作,编程比较复杂,JDK7开始支持。
当前java支持的NIO有一定的问题,比如网络重连、半包读写的问题,以及bug EPoll Bug ,selector空轮询,知道cpu100%,所以使用Netty框架,Netty对NIO做了封装以及事件处理程序,见本专栏Netty章节
这篇好文章是转载于:学新通技术网
- 版权申明: 本站部分内容来自互联网,仅供学习及演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系,请提供相关证据及您的身份证明,我们将在收到邮件后48小时内删除。
- 本站站名: 学新通技术网
- 本文地址: /boutique/detail/tanhfhhiaa
-
photoshop保存的图片太大微信发不了怎么办
PHP中文网 06-15 -
Android 11 保存文件到外部存储,并分享文件
Luke 10-12 -
word里面弄一个表格后上面的标题会跑到下面怎么办
PHP中文网 06-20 -
《学习通》视频自动暂停处理方法
HelloWorld317 07-05 -
微信公众号没有声音提示怎么办
PHP中文网 03-31 -
photoshop扩展功能面板显示灰色怎么办
PHP中文网 06-14 -
excel下划线不显示怎么办
PHP中文网 06-23 -
excel打印预览压线压字怎么办
PHP中文网 06-22 -
怎样阻止微信小程序自动打开
PHP中文网 06-13 -
photoshop蒙版画笔没反应怎么办
PHP中文网 06-24