Java IO模型：BIO、NIO、AIO
本来是打算直接学习网络框架Netty的，但是先补充了一下自己对Java 几种IO模型的学习和理解。分别是 BIO、NIO、AIO三种IO模型。
IO模型的基本说明
BIO模型图
缺点：
- 如果有很多个Client，则会产生很多个线程。压力主要是在服务器端。客户端的压力并不大。
- 另外建立连接之后，并不是在时时刻刻的使用。会有空间时间。
- 会阻塞。
NIO模型图
特点：
- 事件驱动
- 多路复用
- Netty底层使用的NIO模型
AIO模型
目前还未得到广泛运用。异步非阻塞。先了解就可以。
BIO、NIO、AIO使用场景分析
- BOI方式使用与连接数目比较小固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中。JDK1.4以前的唯一选择。但是程序简单容易理解。
- NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务期间通讯等。编程比较复杂，JDK1.4开始支持。
- AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS操作系统参与并发操作，编程比较复杂，JDK7开始支持。但是目前还未得到广泛运用。
JAVA BIO编程
JAVA BIO 基本介绍
JAVA BIO 工作机制
JAVA BIO 应用实例
package com.dawa.netty.bio;
import com.sun.org.apache.xpath.internal.operations.String;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 功能需求
* 1. 使用BIO模型编写一个服务器,监听6666端口,当有客户连接的时候,就启动一个客户端线程与之连接
* 2. 要求使用县城连接机制,可以连接过个客户端
* 3. 服务器端可以接受客户端发送的数据(TeInet方法即可)
*/
public class TestBIO {
public static void main(String[] args) throws Exception {
//1. 创建一个线程池. 这里 借助 Executors 这个工具类
ExecutorService pool = Executors.newCachedThreadPool();
//2. 建立一个监听服务,用来监听客户端连接
ServerSocket serverSocket = new ServerSocket(6666);
while (true) {
final Socket socket = serverSocket.accept();
System.out.println("一个客户端连接");
//就创建一个线程与之通信
pool.execute(new Runnable() {
public void run() {
//编写一个处理方法.
handler(socket);
}
});
}
}
public static void handler(Socket socket) {
byte[] bytes = new byte[1024];
try (InputStream inputStream = socket.getInputStream()) {
while (true) {
int read = inputStream.read(bytes);
if (read != -1) {
//注意这里,不能用String转换了.因为String已经不支持有参数的构造方法.
System.out.println(Arrays.toString(bytes));
} else {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}finally {
System.out.println("关闭连接");
}
}
}
JAVA BIO 问题分析
JAVA NIO编程
NIO 基本介绍
- NIO的三个核心，channel相当于IO的Socket
- Buffer，Channel，Selector(选择器)三大核心组件。
- 通过Buffer实现非阻塞，
- 面向缓冲区，或者面向块编程（Buffer就是这样的）。
- NIO是事件驱动的
NIO Buffer 基本使用
这没有BooleanBuffer，另外StringBuffer继承自StringBuilder.
一个简单的Buffer子类的使用案例如下
package com.dawa.netty.bio;
import java.nio.IntBuffer;
public class TestNIO {
public static void main(String[] args) {
IntBuffer intBuffer = IntBuffer.allocate(5);
for (int i = 0; i < intBuffer.capacity(); i++) {
System.out.println(intBuffer.put(i*5));
}
intBuffer.flip();
while (intBuffer.hasRemaining()) {
System.out.println(intBuffer.get());
}
}
}
NIO 和 BIO 的比较
NIO 三大核心原理示意图
Selector、Channel和Buffer的关系图
- 每个Channel都会对应一个Buffer。
- Selector对应一个线程，一个线程对应多个Channel（连接）。
- 该图反应了有三个Channel注册到该Selector
- 程序切换到哪个Channel是由事件决定的。Event是一个重要概念。
- Select会根据不同的事件，在各个通道上切换。
- Buffer就是一个内存块、底层是由一个数组
- 数据的读取写入是通过Buffer，这个和BIO、BIO中要么是输入流、或者是输出流，不能双向，但是NIO的Buffer是可以读也可以写，需要flip()方法来进行切换。
- Channel也是双向的，可以返回底层操作系统的情况，比如Linux，底层的操作系统通道就是双向的。
三大核心——Buffer缓冲区详解
Buffer的Doc源码（java11）
基本介绍
Buffer的子类
容器对象（函数组），如何理解？从源码中可以看到。Int，Float等，每一个子类Buffer对象，都是[]数组。
具有的四个子类
private int mark = -1; private int position = 0; private int limit; private int capacity;
- 缓冲区的容量是它所包含的元素数量。 缓冲区的容量从不为负，从来没有改变。
- 缓冲区的限制是不应读取或写入的第一个元素的索引。 缓冲区的限制是从不为负，并且永远不会比它更大的容量。
- 缓冲区的位置要被读出或写入的下一个元素的索引。 缓冲区的位置永远不会为负，并且永远不会比它的极限。
// Invariants: mark <= position <= limit <= capacity
代码跟踪-详解
Buffer类及其子类中的重要的方法
如，通过设置position的值，来读取指定位置的值。也可以修改limit的值等。
ByteBuffer
ByteBuffer，是最常用的。二进制数据。
三大核心—— Channel 通道详解
Channel接口的Doc源码（java11）
基本介绍
Channel的子类
FileChannel类
Channel应用实例
Channel应用实例1——本地文件写数据
实例代码如下：
package com.dawa.netty.nio;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class TestNIOFileChannel01 {
public static void main(String[] args) throws Exception{
//准备字符串
String string = "dawa,大娃,Bigbaby";
//准备输出流.指定输出的文件地址
FileOutputStream fileOutputStream = new FileOutputStream("dawa.txt");
//准备Channel管道. 对输出流进行封装,封装为一个channel管道.
FileChannel fileChannel = fileOutputStream.getChannel();
//准备一个byte数组, 也就是一个 Buffer数组,来缓存数据
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//读取数据
byteBuffer.put(string.getBytes());
//这里第一次没有反转,文件里面乱码
byteBuffer.flip();
//完成写的操作
fileChannel.write(byteBuffer);
//关闭流
fileOutputStream.close();
}
}
注意：
- 是FileOutPutStream 包含 NIO FileChannel
- FileChannel的具体的实现类是：FileChannelImpl
Channel应用实例2——本地文件读数据
代码案例如下
package com.dawa.netty.nio;
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
//本地 读文件
public class TestNIOFileChannel02 {
public static void main(String[] args) throws Exception {
//读到文件
File file = new File("dawa.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//fileInputStream 包装为 Channel
FileChannel fileChannel = fileInputStream.getChannel();
//借助Buffer byte[]缓冲数
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
//将Channel的数据读入到byteBuffer
fileChannel.read(byteBuffer);
System.out.println(new String(byteBuffer.array()));
fileInputStream.close();
}
}
Channel应用案例3——使用Buffer完成文件的读写
类似于拷贝的操作，使用文件Channel+Buffer完成
代码案例如下
package com.dawa.netty.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
//使用一个Channel完成文件的读写
public class TestNIOFileChannel03 {
public static void main(String[] args) throws Exception{
FileInputStream fileInputStream = new FileInputStream("dawa.txt");
FileChannel channel01 = fileInputStream.getChannel();
FileOutputStream fileOutputStream = new FileOutputStream("erwa.txt");
FileChannel channel02 = fileOutputStream.getChannel();
//Buffer
ByteBuffer byteBuffer = ByteBuffer.allocate(512);
while (true) {
//这里注意使用Clear操作,不然会进入死循环
/**
* public Buffer clear() {
* position = 0;
* limit = capacity;
* mark = -1;
* return this;
* }
*/
byteBuffer.clear();
int read = channel01.read(byteBuffer);
if (read == -1) {
break;
}
//反转,切换流
byteBuffer.flip();
channel02.write(byteBuffer);
}
fileInputStream.close();
fileOutputStream.close();
}
}
这里需要注意的是使用clear操作,重置缓冲区基本参数
public Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
Channel应用案例4——Transferform拷贝
transferFrom方法
public long transferFrom(ReadableByteChannel src,
long position, long count)
throws IOException
{
ensureOpen();
if (!src.isOpen())
throw new ClosedChannelException();
if (!writable)
throw new NonWritableChannelException();
if ((position < 0) || (count < 0))
throw new IllegalArgumentException();
if (position > size())
return 0;
if (src instanceof FileChannelImpl)
return transferFromFileChannel((FileChannelImpl)src,
position, count);
return transferFromArbitraryChannel(src, position, count);
}
案例如下
package com.dawa.netty.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
//使用一个Channel完成文件的读写
public class TestNIOFileChannel03 {
public static void main(String[] args) throws Exception{
FileInputStream fileInputStream = new FileInputStream("dawa.txt");
FileOutputStream fileOutputStream = new FileOutputStream("erwa.txt");
FileChannel sourceCH = fileInputStream.getChannel();
FileChannel destCH = fileOutputStream.getChannel();
//直接通过通道,完成拷贝
destCH.transferFrom(sourceCH, 0, sourceCH.size());
fileInputStream.close();
fileOutputStream.close();
}
}
关于Buffer和Channel的注意事项和注意细节
- 存取类型需要保持一致（存取顺序一致）
- Buffer可以转为只读Buffer
byteBuffer.asReadOnlyBuffer();
3. **MappedBuffer 可以让文件直接在内存（堆外内存）修改，操作系统不需要拷贝一次**
MappedByteBuffer是抽象类，实际能够操作的类型是 DirectByteBuffer
> 代码案例如下：
```java
package com.dawa.netty.nio;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
//使用 MappedBuffer 直接完成文件在内存中的数据修改
public class MappedBuffer01 {
public static void main(String[] args) throws Exception {
//获取一个读取文件流
RandomAccessFile randomAccessFile = new RandomAccessFile("dawa.txt","rw");
//获取指定的Channel
FileChannel channel = randomAccessFile.getChannel();
//读取模式. 0 代表从0开始, 5代表读取5个字节,也同时意味着只能在内存中操作这5个字节
MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
//对指定位置进行操作
mappedByteBuffer.put(0, (byte) ‘A‘);
mappedByteBuffer.put(2, (byte) 9);
randomAccessFile.close();
channel.close();
}
}
- Scattering&Gathering的使用
Scattering：将数据写入到Buffer时，可以采用Buffer数组，依次写入【分散】
Gathering：从Buffer读取数据时，可以采用Buffer数组，依次读【聚合】
解决的问题：当一个数组不够用的时候，可以用数组组，来完成类似的操作
代码案例如下：使用 数组，来完成客户端 - 服务器端 读取操作
package com.dawa.netty.nio; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Arrays; public class ScatteringGatheringGetPut { public static void main(String[] args) throws Exception { //创建服务器端的 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); //监听端口号 InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 7000); //绑定端口号到服务器端的Channel serverSocketChannel.socket().bind(inetSocketAddress); //创建Buffer数组 ByteBuffer[] byteBuffers = new ByteBuffer[2]; byteBuffers[0] = ByteBuffer.allocate(5); byteBuffers[1] = ByteBuffer.allocate(3); // 等待连接,获取连接, 并生成客户端的 Channel SocketChannel socketChannel = serverSocketChannel.accept(); //假设从 客户端读取 8个字节 int messageLength = 8; while (true) { //1. 将客户端的数据, 读取 int byteRead = 0; while (byteRead < messageLength) { long l = socketChannel.read(byteBuffers); System.out.println("byteRead = " + byteRead); byteRead += 1;//累积读取的字节数 //使用流打印,看看当前Buffer里面的position和limit Arrays.asList(byteBuffers).stream() .map(byteBuffer -> "position=" + byteBuffer.position() + ", limit=" + byteBuffer.limit()).forEach(System.out::println); } //将所有的 Buffer反转 Arrays.asList(byteBuffers).forEach(ByteBuffer::flip); //2. 将读取到的数据,写回客户端 int byteWrite = 0; while (byteWrite < messageLength) { socketChannel.write(byteBuffers); byteWrite += 1; } //将所有的Buffer进行Clear操作 Arrays.asList(byteBuffers).forEach(ByteBuffer::clear); //读完之后,打印出来看看读写文件的长度 System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWrite + ", messageLength" + messageLength); } } }
三大核心—— Selector 选择器详解
Selector的Doc源码（java11）
基本介绍
- 示意图：
Select示意图和特点说明
Selector的子类
Selector类的相关方法
PS：一个线程，对应一个Selector，每个Selector通过调用select()方法，获取不同的能够代表Channel的SelectionKey，得到一个能够被选择的Channel集合。
注意事项
NIO非阻塞网络编程原理分析图
NIO非阻塞网络相关的（Selector、SelectionKey、ServerSocketChannel和SocketChannel）关系图梳理。
对上图的说明
- 当客户端生成时，会通过ServerSocketChannel得到SocketChannel。
- Selector开始监听...Selector进行监听select方法，返回有事件发生的通道的个数。
- 将SocketChannel注册到Selector上.register(Selector sel,int ops).一个Selector上可以注册多个SocketChannel。
SocketChannel的父类里面有注册方法
SelectableChannel里面还有一个注册方法，这个用的比较多
- 注册后，返回一个SelectionKey，会和该Selector关联（集合）
- 进一步得到各个SelectionKey（有事件发生）
- 再通过SelectionKey 反向获取SocketChannel。
SelectionKey类中的channel()方法
- 通过得到的Channel，完成业务处理
NIO非阻塞网络编程快速入门
创建服务器端。
1. 创建ServerSocketChannel ，并设置非阻塞
2. 得到一个Selector对象
3. 绑定一个端口6666.在服务器端监听
4. 把servrSocketChannel 注册到 selector 关心事件为 SelectionKey.OP_ACCEPT
5. 循环等待客户端连接
//这里我们等待一秒，如果没有事件发生，返回
1. if(selector.selecct(1000)==0){//没有事件发生
sout("服务器等待了一秒");
continue;
}
//如果返回的值>0,就获取到相关的selectionKey集合
// 1. 表示已经获取到关注的事件。
// 2. 通过selectionKeys()返回关注的集合。
// 3. 通过selectionKeys
seletor.selectedKeys().var;
//遍历得到的selectionKeys.
//1. 获取SelectionKey
//2. 根据key 对应的通道发生的事件做处理
//3. 如果是 OP_ACCEPT，有新的客户端连接
//1. 给该客户端生成一个SocketChannel
//2. 将SocketChannel 注册到select,关注事件为OP_READ，并关联一个Buffer
//4. 如果是 OP_READ，读取数据
//1. 通过key,反向获取对应的channel
//2. 获取到该channel关联的buffer
//5. 手动从集合中移动单签的SelectionKey，防止重复操作。
创建客户端。
1. 得到一个网络通道SocketChannel.并设置非阻塞
2. 提供服务区的IP和端口，连接服务器
服务器端代码
package com.dawa.netty.nio;
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;
// NIO 服务端
public class TestNIOServer {
public static void main(String[] args) throws Exception {
// 1. 创建ServerSocketChannel ，并设置非阻塞
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
// 2. 得到一个Selector对象
Selector selector = Selector.open();
// 3. 绑定一个端口6666.在服务器端监听
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
// 4. 把serverSocketChannel 注册到 selector 关心事件为 SelectionKey.OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 循环,等待客户端连接
while (true) {
if (selector.select(1000) == 0) {// 没有事件发生
System.out.println("服务器端等待1秒,没有客户端连接");
continue;
}
Set<SelectionKey> selectionKeys = selector.selectedKeys();//得到所有被选中的Key
//循环遍历每一个key,每一个key代表一个事件
Iterator<SelectionKey> iterator = selectionKeys.iterator();
while (iterator.hasNext()) {
SelectionKey selectionKey = iterator.next();
//根据key对应的事件,做响应的处理
if (selectionKey.isAcceptable()) {//如果是 Accept事件, 连接事件,则生成对应的客户端Channel
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
//将SocketChannel 注册到select,关注事件为OP_READ，并关联一个Buffer
socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
}
if (selectionKey.isReadable()) {//如果是读事件
//1. 通过key,反向生成Channel
SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
//设置非同步NIO
socketChannel.configureBlocking(false);
//2. 获取到该channel关联的buffer
ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
socketChannel.read(buffer);
//打印出获取到的Buffer
System.out.println("from 客户端:" + new String(buffer.array()));
}
//这里一定要记得把处理过的key给移除掉,自己遇到了死循环.
iterator.remove();
}
}
}
}
客户端代码
package com.dawa.netty.nio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
//NIO 客户端
public class TestNIOClient {
public static void main(String[] args) throws Exception {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
//服务器端的IP和端口
InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 6666);
if (!socketChannel.connect(socketAddress)) {
System.out.println("连接失败,但是可以干其他事情,非阻塞");
while (!socketChannel.finishConnect()) {
System.out.println("在连接完成之前,我一直干其他的事情");
}
}
String string = "hello,dawa";
socketChannel.write(ByteBuffer.wrap(string.getBytes()));
System.in.read();
}
}
SelectionKey
Selector.keys() 是 列出所有的key。
Selector.selectedKeys()是列出所有被选中的key。
这两个是不一样的。
ServerSocketChannel
SocketChannel
NIO网络编程应用实例——群聊系统
功能示意图
- 先写服务器端
- 服务器端启动并监听6667
- 服务器端接收客户端消息，并实现转发[处理上线和离线]
- 编写客户端
- 连接服务器
- 发送消息
- 接受服务器消息
服务器端代码
- 构造器初始化
- 监听方法
Listen()
里面循环的写法：
里面读数据的方法：
try catch完成离线处理
里面转发给其他客户端的方法
客户端代码
- 构造器初始化
- 向服务器发消息
- 读取从服务器端回复的消息
启动客户端和服务器端
- 启动客户端的方法
- 启动服务器端的方法
自己编码：实现群发
客户端代码
package com.dawa.netty.nio.group;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
//客户端
public class GroupCharClient {
private SocketChannel socketChannel;
private static final int PORT = 6667;
private static final String HOST = "127.0.0.1";
private Selector selector;
private String userName;
public GroupCharClient() throws IOException {
selector = Selector.open();
//连接服务器
socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ);
userName = socketChannel.getRemoteAddress().toString().substring(1);
}
//发送消息
public void sendMessage(String message){
message = userName + "说" + message;
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
try {
socketChannel.write(buffer);
} catch (IOException e) {
e.printStackTrace();
}
}
//读取服务器端发来的消息
public void readMessage() {
try {
int readChannels = selector.select();
if (readChannels > 0) {//有可用的通道
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
if (key.isReadable()) {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
socketChannel.read(buffer);
String msg = new String(buffer.array());
System.out.println(msg.trim());
}
}
} else {
//没有可用的通道
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
GroupCharClient groupCharClient = new GroupCharClient();
new Thread(() -> {
while (true) {
groupCharClient.readMessage();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
//发送数据给服务器端
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String message = scanner.nextLine();
groupCharClient.sendMessage(message);
}
}
}
服务器端代码
package com.dawa.netty.nio.group;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
/**
* 服务器端代码
*/
public class GroupChatServer {
private ServerSocketChannel serverSocketChannel;
private Selector selector;
private static final int PORT = 6666;
public GroupChatServer() {
try {
//得到选择器
selector = Selector.open();
//绑定端口
serverSocketChannel = ServerSocketChannel.open().bind(new InetSocketAddress(PORT));
} catch (IOException e) {
e.printStackTrace();
}
}
//服务器端监听的方法
public void listen() {
try {
//循环监听
while (true) {
int count = selector.select();
if (count > 0) {
Iterator<SelectionKey> selectionKeyIterator = selector.selectedKeys().iterator();
while (selectionKeyIterator.hasNext()) {
//取出Key
SelectionKey key = selectionKeyIterator.next();
//判断事件
if (key.isAcceptable()) {//监听访问
//key 转Channel
SocketChannel channel = serverSocketChannel.accept();
SocketAddress remoteAddress = channel.getRemoteAddress();
System.out.println(remoteAddress + ":上线了");
}
if (key.isReadable()) {//读取事件
//处理读
readData(key);
}
//移除已经处理的key
selectionKeyIterator.remove();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
//读数据
public void readData(SelectionKey key) {
SocketChannel channel = null;
try {
//根据key,取得Channel
channel = (SocketChannel) key.channel();
channel.configureBlocking(false);
ByteBuffer buffer = ByteBuffer.allocate(1024);
int read = channel.read(buffer);
if (read > 0) {
String message = new String(buffer.array());
System.out.println("from: 客户端" + message);
// 向其他用户,转发消息
sendMessageToOtherCLient(message,key);
}
} catch (IOException e) {
try {
System.out.println(channel.getRemoteAddress() + " :离线了");
key.cancel();
channel.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
//向其他用户转发消息
public void sendMessageToOtherCLient(String message,SelectionKey self){
System.out.println("服务器转发消息ing");
selector.keys().forEach(key -> {
//根据Key,取出对应的SocketChannel.或者是ServerSocketChannel
Channel targetChannel = key.channel();
//排除自己
if (targetChannel instanceof SocketChannel && targetChannel != self) {
//转型
SocketChannel dest = (SocketChannel) targetChannel;
//Buffer
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
try {
dest.write(buffer);
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
public static void main(String[] args) {
GroupChatServer groupChatServer = new GroupChatServer();
groupChatServer.listen();
}
}
NIO与零拷贝
什么是零拷贝？
零拷贝，指的是没有CPU拷贝，而不是不拷贝。从操作系统角度看的。
基本介绍
传统IO数据读写
传统IO模型图，状态切换：用户态和内核态的切换：4次拷贝，3次切换
MMAP优化
Mmap优化：3次拷贝，3次切换
DMA拷贝：direct memory accect:直接内存访问
sendFile优化
sendFile优化：三次拷贝，两次切换
零拷贝
零拷贝，指的是没有CPU拷贝，而不是不拷贝。从操作系统角度看的。
这里其实还有一次CPU拷贝的：kernel buffer->socket buffer但是，拷贝的信息很少，比如length，offset，消耗低，可以忽略
零拷贝：2次拷贝，2次切换。
零拷贝是我们在进行网络传输的重要优化手段。
mmap和sendFile的区别：
NIO零拷贝案例
传统IO流案例
传统IO耗费时间：60毫秒
零拷贝案例。（NIO）
transferTo 底层用的就是零拷贝
NIO零拷贝耗时时间：20毫秒
Java AIO编程
Java AIO基本介绍
这里暂时不深入扩展。
BIO、NIO、AIO对比表
原文地址：https://www.cnblogs.com/bigbaby/p/12596350.html
时间： 2024-11-05 11:00:54