BIO、NIO、AIO
- Java BIO : 同步并阻塞,服务端实现模式为一个连接一个线程,即客户端有连接请求时服务端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。
- Java NIO : 同步非阻塞,服务端实现模式为一个请求一个线程,即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
- Java AIO(NIO.2) : 异步非阻塞,服务端实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务应用去启动线程进行处理。
一、适用场景
BIO
适用于连接数目比较小且固定的架构,这种方式对服务端资源要求比较高,并发局限于应用中。JDK1.4前的唯一选择,程序简单易于理解
NIO
适用于连接数目多但连接时间比较短(轻操作)的架构,比如聊天服务端,弹幕系统,服务期间通讯等。JDK1.4开始支持,程序较为复杂
AIO
适用于连接数目多且连接数目比较长(重操作)的架构,比如相册服务端,充分调用OS参与并发操作。JDK7开始支持,程序较为复杂
二、JAVA BIO
1. BIO基本介绍
- java BIO 就是传统的 java io 编程,其相关的类和接口在 java.io
- BIO(blocking I/O):同步阻塞IO,服务端实现模式为一个连接一个线程,即客户端有连接请求时服务端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的系统开销,可以通过线程池机制改善(实现多个客户连接服务端)
2. JAVA BIO 工作机制
3. 传统BIO实例
网络编程的基本模型是Client/Server模型,也就是两个进程之间进行相互通信,其中服务端提供位置信(绑定IP地址和端口),客户端通过连接操作向服务端监听的端口地址发起连接请求,基于TCP协议下进行三次握手连接,连接成功后,双方通过网络套接字(Socket)进行通信。
传统的同步阻塞模型开发中,服务端ServerSocket负责绑定IP地址,启动监听端口;客户端Socket负责发起连接操作。连接成功后,双方通过输入和输出流进行同步阻塞式通信。
基于BIO模式下的通信,客户端 - 服务端是完全同步,完全耦合的。
服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Author: permission
* @Date: 2021/9/28 11:41
* @Version: 1.0
* @ClassName: Server
* @Description: 服务端:接收客户端发送的消息
*/
public class Server {
public static void main(String[] args) {
try {
//1.定义一个ServerSocket对象进行服务端的端口注册
ServerSocket serverSocket = new ServerSocket(9999);
//2.监听客户端的Socket请求(调用accept方法)
Socket socket = serverSocket.accept();
//3.从Socket管道获取字节输入流对象
InputStream is = socket.getInputStream();
//4.把字节输入流包装成缓冲字符输入流(字节流不能按行读取)
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//5.读取客户端发送的数据
String msg;
if ((msg = br.readLine()) != null) {
System.out.println("服务端接收到:" + msg);
}
//6.关闭流对象
// br.close();
// is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Locale;
/**
* @Author: permission
* @Date: 2021/9/28 11:41
* @Version: 1.0
* @ClassName: Client
* @Description: 客户端
*/
public class Client {
public static void main(String[] args) throws UnknownHostException {
try {
//1.创建Socket对象请求连接服务端
Socket socket = new Socket(InetAddress.getLocalHost(),9999);
//2.从Socket对象获取字节输出流
OutputStream os = socket.getOutputStream();
//3.把字节输出流包装成一个打印流(字节流不方便按行操作)
PrintStream ps = new PrintStream(os);
//4.打印到Socket管道
ps.println("这里是一个客户端");
ps.flush();
//5.关闭流对象
// ps.close();
// os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
总结
- 在以上通信中,服务端会一直等待客户端的消息,如果客户端没有进行消息的发送,服务端将一直进入阻塞状态
- 同时服务端是按照行读取消息的,这意味着客户端必须按照行进行消息的发送,否则服务端将进入等待消息的阻塞状态
- 不关闭流对象时,服务端会一直等待客户端发送行消息,当客户端运行完主线程销毁后(Socket管道也销毁),服务端发现客户端Socket已销毁后(一方Socket销毁后,另一方会抛出异常)会报以下异常:java.net.SocketException: Connection reset (关闭流对象后不会抛出此异常)
- 当客户端使用 print 方法时,因为服务端是按行读取(本案例中,无法识别print的是一行),所以会一直堵塞等待客户端发送换行标识(如果客户端没有)
4. BIO模式下的多发和多收
服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Author: permission
* @Date: 2021/9/29 12:45
* @Version: 1.0
* @ClassName: Server
* @Description: 服务端 多收
*/
public class Server {
public static void main(String[] args) {
try {
//1.定义一个ServerSocket对象进行服务端的端口注册
ServerSocket serverSocket = new ServerSocket(9999);
//2.监听客户端的Socket请求(调用accept方法)
Socket socket = serverSocket.accept();
//3.从Socket管道获取字节输入流对象
InputStream is = socket.getInputStream();
//4.把字节输入流包装成缓冲字符输入流(字节流不能按行读取)
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//5.读取客户端发送的数据
String msg;
while ((msg = br.readLine()) != null) {
System.out.println("服务端接收到:" + msg);
}
//6.关闭流对象
// br.close();
// is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
/**
* @Author: permission
* @Date: 2021/9/29 12:45
* @Version: 1.0
* @ClassName: Client
* @Description: 客户端 多发
*/
public class Client {
public static void main(String[] args) {
try {
//1.创建Socket对象请求连接服务端
Socket socket = new Socket(InetAddress.getLocalHost(),9999);
//2.从Socket对象获取字节输出流
OutputStream os = socket.getOutputStream();
//3.把字节输出流包装成一个打印流(字节流不方便按行操作)
PrintStream ps = new PrintStream(os);
//4.打印到Socket管道
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入:");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
//5.关闭流对象
// ps.close();
// os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. BIO模式下接收多个客户端
为每个客户端请求创建一个线程
服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Author: permission
* @Date: 2021/9/29 13:25
* @Version: 1.0
* @ClassName: Server
* @Description: 服务端
*/
public class Server {
/**
* 实现接收多个客户端
* @param args
*/
public static void main(String[] args) {
try {
//1.定义一个ServerSocket对象进行服务端的端口注册
ServerSocket serverSocket = new ServerSocket(9999);
while (true) {
//2.监听客户端的Socket请求(调用accept方法)
Socket socket = serverSocket.accept();
//3.创建线程 接收客户端信息
new ServerReadThread(socket).start();
System.out.println(socket.getRemoteSocketAddress()+"上线了");
}
} catch (IOException e) {
e.printStackTrace();
}
}
static class ServerReadThread extends Thread {
private Socket socket;
public ServerReadThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//1.从Socket管道获取字节输入流对象
InputStream is = socket.getInputStream();
//2.把字节输入流包装成缓冲字符输入流(字节流不能按行读取)
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//3.读取客户端发送的数据
String msg;
while ((msg = br.readLine()) != null) {
System.out.println("服务端接收到来自"+ socket.getRemoteSocketAddress()+ "的信息:" + msg);
}
//6.关闭流对象
br.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
客户端
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
/**
* @Author: permission
* @Date: 2021/9/29 13:35
* @Version: 1.0
* @ClassName: Client
* @Description: 客户端
*/
public class Client {
public static void main(String[] args) {
try {
//1.创建Socket对象请求连接服务端
Socket socket = new Socket(InetAddress.getLocalHost(),9999);
//2.从Socket对象获取字节输出流
OutputStream os = socket.getOutputStream();
//3.把字节输出流包装成一个打印流(字节流不方便按行操作)
PrintStream ps = new PrintStream(os);
//4.打印到Socket管道
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入:");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
总结
- 每个Socket接收到,都会创建一个线程,线程的竞争、切换上下文影响性能
- 每个线程都会占用栈空间和CPU资源
- 并不是每个socket都进行IO操作,无意义的线程处理
- 客户端的并发访问增加时。服务端将呈现 1 : 1 的线程开销,访问量过大,系统会发生线程栈溢出,线程创建失败,最终导致进程宕机或者僵死,从而不能对外提供服务
6. 伪异步I/O编程
采用一个伪异步I/O的通信框架,采用线程池和任务队列实现,当客户端接入时,将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。线程池维护一个消息队列和N个活跃的线程,对消息队列中Socket任务进行处理,由于线程池可以设置消息队列的大小和最大线程数,因此,它的资源占用是可控的,无论多少个客户端并发访问,都不会导致资源的耗尽和宕机。
服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* @Author: permission
* @Date: 2021/9/29 15:03
* @Version: 1.0
* @ClassName: Server
* @Description: 实现伪异步BIO
*/
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(9999);
HandlerServerSocketPool pool = new HandlerServerSocketPool(6, 10);
while (true) {
Socket socket = serverSocket.accept();
Runnable target = new ServerRunnableTarget(socket);
pool.execute(target);
}
} catch (Exception e) {
e.printStackTrace();
}
}
static class ServerRunnableTarget implements Runnable {
Socket socket;
public ServerRunnableTarget(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//1.从Socket管道获取字节输入流对象
InputStream is = socket.getInputStream();
//2.把字节输入流包装成缓冲字符输入流(字节流不能按行读取)
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//3.读取客户端发送的数据
String msg;
while ((msg = br.readLine()) != null) {
System.out.println("服务端接收到来自"+ socket.getRemoteSocketAddress()+ "的信息:" + msg);
}
//6.关闭流对象
br.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
线程池处理类
import java.util.concurrent.*;
/**
* @Author: permission
* @Date: 2021/9/29 15:24
* @Version: 1.0
* @ClassName: HandlerServerSocketPool
* @Description:
*/
public class HandlerServerSocketPool {
/**
* 1.创建一个线程池的成员变量用于存储一个线程池对象
*/
private ExecutorService executorService;
/**
* 2.创建类对象时,初始化线程池对象
* public ThreadPoolExecutor(int corePoolSize,
* int maximumPoolSize,
* long keepAliveTime,
* TimeUnit unit,
* BlockingQueue<Runnable> workQueue)
*/
public HandlerServerSocketPool(int maxThreadNum, int queueSize) {
executorService = new ThreadPoolExecutor(3,maxThreadNum,7000, TimeUnit.MICROSECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
// executorService = Executors.newCachedThreadPool();
}
/**
* 3.提供一个方法来提交任务给线程池的任务队列来暂存,等待线程池处理
*/
public void execute(Runnable target) {
executorService.execute(target);
}
}
客户端
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
/**
* @Author: permission
* @Date: 2021/9/29 13:35
* @Version: 1.0
* @ClassName: Client
* @Description: 客户端
*/
public class Client {
public static void main(String[] args) {
try {
//1.创建Socket对象请求连接服务端
Socket socket = new Socket(InetAddress.getLocalHost(),9999);
//2.从Socket对象获取字节输出流
OutputStream os = socket.getOutputStream();
//3.把字节输出流包装成一个打印流(字节流不方便按行操作)
PrintStream ps = new PrintStream(os);
//4.打印到Socket管道
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入:");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
总结
- 伪异步io采用了线程池实现,因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题,但由于底层依然是采用的同步阻塞模型,因此无法从根本上解决问题
- 如果单个消息处理的缓慢,或者服务端线程池中的全部线程都被阻塞,那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝,客户端会发生大量连接超时
7. 基于BIO模式下的文件上传
服务端
import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.UUID;
import java.util.concurrent.*;
/**
* @Author: permission
* @Date: 2021/9/29 16:07
* @Version: 1.0
* @ClassName: Server
* @Description: 基于BIO模式的文件上传
*/
/**
* 实现客户端上传任意类型的文件数据给服务端保存起来
*/
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(9999);
while (true) {
Socket socket = serverSocket.accept();
ExecutorService executorService = new ThreadPoolExecutor(3, 6, 7, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
executorService.execute(() -> {
try {
//1.得到一个数据输入流,读取客户端发送的信息
DataInputStream dis = new DataInputStream(socket.getInputStream());
//2.读取客户端发送的文件类型
String suffix = dis.readUTF();
System.out.println("服务端接收到文件类型:" + suffix);
//3.定义一个字节输出流将客户端发送的文件保存
OutputStream os = new FileOutputStream("C:\\Users\\permission\\Desktop\\ccc\\server\\" +
UUID.randomUUID() + suffix);
//4.从数据输入流中读取文件数据,写到字节输出流中
byte[] buffer = new byte[1024];
int len;
while ((len = dis.read(buffer)) > 0) {
os.write(buffer, 0 ,len);
}
os.close();
System.out.println("服务端收到文件,并保存成功!");
} catch (Exception e) {
e.printStackTrace();
}
});
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
客户端
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* @Author: permission
* @Date: 2021/9/29 16:07
* @Version: 1.0
* @ClassName: Client
* @Description:
*/
public class Client {
public static void main(String[] args) {
try {
//1.请求与服务端的Socket连接
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//2.把字节输出流包装为一个数据输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//3.先发送要上传文件的后缀(文件格式)到服务端
dos.writeUTF(".png");
//4.把文件数据发送到服务端
InputStream is = new FileInputStream(new File("C:\\Users\\permission\\Desktop\\ccc\\imgs\\20210813082812.png"));
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) > 0) {
dos.write(buffer, 0, len);
}
dos.flush();
//通知服务端数据发送完毕 (连接重置异常)
socket.shutdownOutput();
} catch (Exception e) {
e.pr
intStackTrace();
}
}
}
8. BIO模式下的端口转发
客户端
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
/**
* @Author: permission
* @Date: 2021/10/4 13:21
* @Version: 1.0
* @ClassName: Server
* @Description:
*/
public class Server {
//定义一个静态集合,保存在线socket
public static List<Socket> allSocketOnline = new ArrayList<>();
/**
* BIO模式下的端口转发 服务端
*
* 1、注册端口
* 2、接收客户端的socket连接,交给一个独立的线程处理
* 3、把当前连接的客户端socket存入到一个在线socket集合中保存
* 4、接收客户端消息,推送给所有在线用户
*
*/
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(9999);
while (true) {
Socket socket = serverSocket.accept();
//把在线的客户端socket存入到List
allSocketOnline.add(socket);
//分配独立的线程处理
new Thread(() -> {
try {
// 1、从socket获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 2、读取客户端发送的消息
String msg;
while ((msg = br.readLine()) != null) {
System.out.println(msg);
// 3、推送给所有在线客户端
sendMsgToAllClient(msg);
}
} catch (IOException e) {
//客户端关闭,捕获到连接重置异常,将对应socket移除在线List
System.out.println(socket.getRemoteSocketAddress() + " 下线");
allSocketOnline.remove(socket);
}
}).start();
}
} catch (Exception e) {
}
}
/**
* 把当前接收到的客户端发送的消息推送到所有在线客户端
*/
private static void sendMsgToAllClient(String msg) {
try {
for (Socket socket : allSocketOnline) {
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println(msg);
ps.flush();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
三、 JAVA NIO
1. 基本介绍
- Java NIO(New IO)也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API,可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的,但是使用的方式完全不同,NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传统的IO的read和write只能阻塞执行,线程在读写IO期间不能干其他事情,比如调用socket.read()时,如果服务端一直没有数据传输过来,线程就一直阻塞,而NIO中可以配置socket为非阻塞模式。
- NIO 相关类都被放在 java.nio 包及子包下,并且对原 java.io 包中的很多类进行改写。
- NIO 有三大核心部分:Channel( 通道) ,Buffer( 缓冲区), Selector( 选择器)
- Java NIO 的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。 非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。
- 通俗理解:NIO 是可以做到用一个线程来处理多个操作的。假设有 1000 个请求过来,根据实际情况,可以分配20 或者 80个线程来处理。不像之前的阻塞 IO 那样,非得分配 1000 个。
2. NIO与BIO比较
- BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的,NIO 则是非阻塞的
- BIO 基于字节流和字符流进行操作,而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道
NIO | BIO |
---|---|
面向缓冲区(Buffer) | 面向流(Stream) |
非阻塞(Non Blocking IO) | 阻塞IO(Blocking IO) |
选择器(Selectors) |
3. NIO三大核心部分
-
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 是可以读也可以写。
-
Java NIO系统的核心在于:通道(Channel)和缓冲区 (Buffer)。通道表示打开到 IO 设备(例如:文件、 套接字)的连接。若需要使用 NIO 系统,需要获取 用于连接 IO 设备的通道以及用于容纳数据的缓冲 区。然后操作缓冲区,对数据进行处理。简而言之,Channel 负责传输, Buffer 负责存取数据
Buffer
一个用于特定基本数据类型的容器。由 java.nio 包定义的,所有缓冲区 都是 Buffer 抽象类的子类.。Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互,数据是从通道读入缓冲区,从缓冲区写入通道中的
缓冲区的基本属性
Buffer 中的重要概念:
- 容量 (capacity) :作为一个内存块,Buffer具有一定的固定大小,也称为"容量",缓冲区容量不能为负,并且创建后不能更改。
- 限制 (limit):表示缓冲区中可以操作数据的大小(limit 后数据不能进行读写)。缓冲区的限制不能为负,并且不能大于其容量。 写入模式,限制等于buffer的容量。读取模式下,limit等于写入的数据量。
- 位置 (position):下一个要读取或写入的数据的索引。缓冲区的位置不能为 负,并且不能大于其限制
- 标记 (mark)与重置 (reset):标记是一个索引,通过 Buffer 中的 mark() 方法 指定 Buffer 中一个特定的 position,之后可以通过调用 reset() 方法恢复到这 个 position.
标记、位置、限制、容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity
Buffer 类及其子类
Buffer 就像一个数组,可以保存多个相同类型的数据。根 据数据类型不同 ,有以下 Buffer 常用子类:
- ByteBuffer
- CharBuffer
- ShortBuffer
- IntBuffer
- LongBuffer
- FloatBuffer
- DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据,只是各自 管理的数据类型不同而已。都是通过如下方法获取一个 Buffer 对象:
public static xBuffer allocate(int capacity) //创建一个容量为capacity的 xxxBuffer对象
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读写数据一般遵循以下四个步骤:
- 1.写入数据到Buffer
- 2.调用flip()方法,转换为读取模式
- 3.从Buffer中读取数据
- 4.调用
buffer.clear()
方法或者buffer.compact()
方法清除缓冲区
import org.junit.jupiter.api.Test;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
/**
* @Author: permission
* @Date: 2021/10/6 9:22
* @Version: 1.0
* @ClassName: BufferDemo
* @Description:
*/
/*
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
*/
public class BufferTest {
@Test
public void t1(){
// 1.分配一个缓冲区,容量设置为10
ByteBuffer buffer = ByteBuffer.allocate(10);
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
// 2.put()方法向缓冲区添加数据
String name = "cccxxx";
buffer.put(name.getBytes(StandardCharsets.UTF_8));
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
// 3.flip()方法 将limit设置为当前position的值,并将position位置重置为0 也就是切换为可读模式
buffer.flip();
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
// 4.get()方法从缓冲区读取数据
char ch = (char) buffer.get();
System.out.println(ch);
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
}
@Test
public void t2(){
// 1.分配一个缓冲区,容量设置为10
ByteBuffer buffer = ByteBuffer.allocate(10);
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
// 2.put()方法向缓冲区添加数据
String name = "cccxxx";
buffer.put(name.getBytes(StandardCharsets.UTF_8));
buffer.flip();
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
System.out.println("---------------------------------------");
// 3.clear()方法 清除缓冲区数据 只是将position、limit重置,原数据依旧存在
buffer.clear();
System.out.println("capacity: " + buffer.capacity());
System.out.println("limit: " + buffer.limit());
System.out.println("position: " + buffer.position());
//原数据依然存在
System.out.println((char) buffer.get());
System.out.println("---------------------------------------");
// 定义一个新的缓冲区
ByteBuffer buffer2 = ByteBuffer.allocate(10);
String cc = "xxxccc";
buffer2.put(cc.getBytes(StandardCharsets.UTF_8));
System.out.println("capacity: " + buffer2.capacity());
System.out.println("limit: " + buffer2.limit());
System.out.println("position: " + buffer2.position());
buffer2.flip();
System.out.println("position: " + buffer2.position());
byte[] b = new byte[2];
buffer2.get(b);
System.out.println(new String(b));
System.out.println("capacity: " + buffer2.capacity());
System.out.println("limit: " + buffer2.limit());
System.out.println("position: " + buffer2.position());
//标记此时位置
buffer2.mark();
byte[] b2 = new byte[3];
buffer2.get(b2);
System.out.println(new String(b2));
System.out.println("position: " + buffer2.position());
buffer2.reset();
System.out.println("position: " + buffer2.position());
int i = buffer2.remaining();
System.out.println(i);
System.out.println("---------------------------------------");
}
@Test
public void t3(){
// 1.创建一个直接内存缓冲区
ByteBuffer buffer = ByteBuffer.allocateDirect(10);
System.out.println(buffer.isDirect()); //判断是否为直接内存缓冲区
System.out.println("---------------------------------------");
}
}
直接与非直接缓冲区
根据官方文档的描述:
ByteBuffer
可以是两种类型,一种是基于直接内存(也就是非堆内存);另一种是非直接内存(也就是堆内存)。对于直接内存来说,JVM将会在IO操作上具有更高的性能,因为它直接作用于本地系统的IO操作。而非直接内存,也就是堆内存中的数据,如果要作IO操作,会先从本进程内存复制到直接内存,再利用本地IO处理。
从数据流的角度,非直接内存是下面这样的作用链:
本地IO-->直接内存-->非直接内存-->直接内存-->本地IO
而直接内存是:
本地IO-->直接内存-->本地IO
很明显,在做IO处理时,比如网络发送大量数据时,直接内存会具有更高的效率。直接内存使用allocateDirect创建,但是它比申请普通的堆内存需要耗费更高的性能。**不过,这部分的数据是在JVM之外的,因此它不会占用应用的内存。**所以呢,当你有很大的数据要缓存,并且它的生命周期又很长,那么就比较适合使用直接内存。只是一般来说,如果不是能带来很明显的性能提升,还是推荐直接使用堆内存。字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。
使用场景
- 1 有很大的数据需要存储,它的生命周期又很长
- 2 适合频繁的IO操作,比如网络并发场景
Channel
通道Channe概述
通道(Channel): 由 java.nio.channels
包定义 的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据,Channel 只能与 Buffer 进行交互。
1、 NIO 的通道类似于流,但有些区别如下:
- 通道可以同时进行读写,而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据,也可以写数据到缓冲:
2、BIO 中的 stream 是单向的,例如 FileInputStream
对象只能进行读取数据的操作,而 NIO 中的通道(Channel)
是双向的,可以读操作,也可以写操作。
3、Channel 在 NIO 中是一个接口
public interface Channel extends Closeable{}
常用的Channel实现类
- FileChannel:用于读取、写入、映射和操作文件的通道。
- DatagramChannel:通过 UDP 读写网络中的数据通道。
- SocketChannel:通过 TCP 读写网络中的数据。
- ServerSocketChannel:可以监听新进来的 TCP 连接,对每一个新进来的连接都会创建一个 SocketChannel。 【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
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) 强制将所有对此通道的文件更新写入到存储设备中
写入数据到本地文件
/**
* 输出数据到文件
*/
@Test
public void t1(){
try {
// 1.字节输出流通向目标文件
FileOutputStream fos = new FileOutputStream("data01.txt");
// 2.获取字节输出流对应的通道channel
FileChannel channel = fos.getChannel();
// 3.分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("hello,这里是ccc".getBytes());
// 4.切换为写出模式
buffer.flip();
// 5.写出
channel.write(buffer);
// 6.关闭channel
channel.close();
System.out.println("文本已经写入到文件");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
从本地文件读取数据
/**
* 从文件读取数据
*/
@Test
public void t2(){
try {
// 1.创建字节输入流
FileInputStream fis = new FileInputStream("data01.txt");
// 2.获取文件字节输入流的文件通道
FileChannel fisChannel = fis.getChannel();
// 3.分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 4.读取数据到缓冲区
fisChannel.read(buffer);
// // 5.从缓冲区中获取数据并输出 直接读取发现缓冲区中没有数据的位置也读取并输出,所以采用以下方法读取
// String rs = new String(buffer.array());
// System.out.println(rs);
// 5.从缓冲区中获取数据并输出
buffer.flip();
String rs = new String(buffer.array(), 0, buffer.remaining());
System.out.println(rs);
// 6.关闭channel
fisChannel.close();
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
文件复制
/**
* 复制
*/
@Test
public void t3() throws Exception {
//源文件
File file = new File("C:\\Users\\permission\\Desktop\\e8017986-bf78-4e32-b3d1-96c6f39823dd.png");
//目标文件
File copyFile = new File("C:\\Users\\permission\\Desktop\\aCopy.png");
//创建字节输入流
FileInputStream fis = new FileInputStream(file);
//创建字节输出流
FileOutputStream fos = new FileOutputStream(copyFile);
FileChannel fisChannel = fis.getChannel();
FileChannel fosChannel = fos.getChannel();
//分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
//循环读取、写入数据
while (true) {
//清空缓冲区
buffer.clear();
//开始读取一次数据
int flag = fisChannel.read(buffer);
//判断是否读完
if (flag == -1) {
break;
}
//重置position位置(0)
buffer.flip();
//写入一次数据
fosChannel.write(buffer);
}
//关闭
// fosChannel.close();
// fisChannel.close();
//流对象的close()方法会判断channel是否为空,不为空关闭channel
fos.close();
fis.close();
// System.out.println(fosChannel.isOpen()); //输出为false,表示channel已关闭
System.out.println("复制完成");
}
分散 (Scatter) 读取和聚集 (Gather)写入
分散读取(Scatter ):是指把Channel通道的数据读入到多个缓冲区中去
聚集写入(Gathering ):是指将多个 Buffer 中的数据“聚集”到 Channel。
/**
* 分散读取和聚集写入
*/
@Test
public void t4() throws Exception {
// 1.字节输入channel
FileInputStream fis = new FileInputStream("data01.txt");
FileChannel fisChannel = fis.getChannel();
// 2.字节输出channel
FileOutputStream fos = new FileOutputStream("data02.txt");
FileChannel fosChannel = fos.getChannel();
// 3.创建多个缓冲区
ByteBuffer buffer = ByteBuffer.allocate(2);
ByteBuffer buffer2 = ByteBuffer.allocate(7);
ByteBuffer buffer3 = ByteBuffer.allocate(1024);
ByteBuffer[] buffers = {buffer,buffer2,buffer3};
// 4.从channel中读取数据,分散到各个缓冲区
fisChannel.read(buffers);
// // 遍历各个缓冲区,查询是否有数据
// for (ByteBuffer bb : buffers) {
// bb.flip();
// String rs = new String(bb.array(), 0, bb.remaining());
// System.out.println(rs);
// }
// 5.聚集写入数据
fosChannel.write(buffers);
// 6.关闭
fos.close();
fis.close();
System.out.println("完成······");
}
transferFrom()
从目标通道中去复制原通道数据
/**
* transferFrom()
* 从目标通道中去复制原通道数据
*/
@Test
public void t5() throws Exception {
// 1.字节输入管道
FileInputStream fis = new FileInputStream("data01.txt");
FileChannel fisChannel = fis.getChannel();
// 2.字节输出管道
FileOutputStream fos = new FileOutputStream("data03.txt");
FileChannel fosChannel = fos.getChannel();
// 3.复制
fosChannel.transferFrom(fisChannel, fisChannel.position(), fisChannel.size());
// 4.关闭
fos.close();
fis.close();
System.out.println("已完成···");
}
transferTo()
把原通道数据复制到目标通道
/**
* transferTo()
* 把原通道数据复制到目标通道
*/
@Test
public void t6() throws Exception {
// 1、字节输入管道
FileInputStream fis = new FileInputStream("data01.txt");
FileChannel fisChannel = fis.getChannel();
// 2、字节输出流管道
FileOutputStream fos = new FileOutputStream("data04.txt");
FileChannel fosChannel = fos.getChannel();
// 3、复制
fisChannel.transferTo(fisChannel.position(), fisChannel.size(), fosChannel);
fos.close();
fis.close();
System.out.println("已完成···");
}
Selector(选择器)
选择器(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 (1)
- 写 : SelectionKey.OP_WRITE (4)
- 连接 : SelectionKey.OP_CONNECT (8)
- 接收 : SelectionKey.OP_ACCEPT (16)
- 若注册时不止监听一个事件,则可以使用“位或”操作符连接。
int interestSet = SelectionKey.OP_READ|SelectionKey.OP_WRITE
NIO非阻塞式网络通信原理分析
Selector 示意图和特点说明
Selector可以实现: 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作,这从根本上解决了传统同步阻塞 I/O 一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PWwWwSqF-1658637757797)(imgs/image-20211011170554502.png)]
服务端流程
1、获取通道:当客户端连接服务端时,服务端会通过 ServerSocketChannel 得到 SocketChannel:
ServerSocketChannel ssChannel = ServerSocketChannel.open();
2、切换非阻塞模式
ssChannel.configureBlocking(false);
3、绑定连接
ssChannel.bind(new InetSocketAddress(9999));
4、 获取选择器
Selector selector = Selector.open();
5、 将通道注册到选择器上, 并且指定“监听接收事件”
ssChannel.register(selector, SelectionKey.OP_ACCEPT);
6、轮询式的获取选择器上已经“准备就绪”的事件
//轮询式的获取选择器上已经“准备就绪”的事件
while (selector.select() > 0) {
System.out.println("轮一轮");
//7. 获取当前选择器中所有注册的“选择键(已就绪的监听事件)”
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
//8. 获取准备“就绪”的是事件
SelectionKey sk = it.next();
//9. 判断具体是什么事件准备就绪
if (sk.isAcceptable()) {
//10. 若“接收就绪”,获取客户端连接
SocketChannel sChannel = ssChannel.accept();
//11. 切换非阻塞模式
sChannel.configureBlocking(false);
//12. 将该通道注册到选择器上
sChannel.register(selector, SelectionKey.OP_READ);
} else if (sk.isReadable()) {
//13. 获取当前选择器上“读就绪”状态的通道
SocketChannel sChannel = (SocketChannel) sk.channel();
//14. 读取数据
ByteBuffer buf = ByteBuffer.allocate(1024);
int len = 0;
while ((len = sChannel.read(buf)) > 0) {
buf.flip();
System.out.println(new String(buf.array(), 0, len));
buf.clear();
}
}
//15. 取消选择键 SelectionKey
it.remove();
}
}
}
客户端流程
-
获取通道
SocketChannel sChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
-
切换非阻塞模式
sChannel.configureBlocking(false);
-
分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);
-
发送数据给服务端
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(); } //关闭通道 sChannel.close();
NIO非阻塞式网络通信入门案例
服务端接收客户端的连接请求,并接收多个客户端发送过来的事件。
服务端
public class Server {
public static void main(String[] args) {
try {
// 1.获取通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 2.设置为非阻塞模式
serverSocketChannel.configureBlocking(false);
// 3.绑定端口
serverSocketChannel.bind(new InetSocketAddress(9999));
// 4.获取选择器
Selector selector = Selector.open();
// 5.将channel注册到选择器,并指定监听接收事件
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 6.使用选择器轮询是否有已经就绪的事件
while (selector.select() > 0) {
// 7.获取所有已就绪事件
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
// 8.遍历事件
while (it.hasNext()) {
// 获取一个事件
SelectionKey sk = it.next();
// 9.判断事件是否为接入事件
if (sk.isAcceptable()) {
// 10.获取当前接入的客户端通道
SocketChannel socketChannel = serverSocketChannel.accept();
// 11.设置为非阻塞模式
socketChannel.configureBlocking(false);
// 12.将此客户端channel注册到选择器,并指定监听读事件
socketChannel.register(selector, SelectionKey.OP_READ);
}
// 13.判断事件是否为读事件
else if (sk.isReadable()) {
// 14.获取当前接入的客户端通道
SocketChannel socketChannel = (SocketChannel) sk.channel();
// 15.读取数据
ByteBuffer buffer = ByteBuffer.allocate(1024);
int len = 0;
while ((len = socketChannel.read(buffer)) > 0) {
buffer.flip();
System.out.println(new String(buffer.array(), 0, len));
buffer.clear();
}
}
// 处理完毕后移除
it.remove();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
客户端
public class Client {
public static void main(String[] args) {
try {
// 1.获取channel
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress(InetAddress.getLocalHost(), 9999));
// 2.设置为非阻塞模式
socketChannel.configureBlocking(false);
// 3.分配缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 4.发送数据
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("请输入:");
String msg = scanner.nextLine();
buffer.put(msg.getBytes());
buffer.flip();
socketChannel.write(buffer);
buffer.clear();
System.out.println(socketChannel.getLocalAddress() + ":发送成功!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
三、JAVA AIO
AIO
- Java AIO(NIO.2) : 异步非阻塞,服务端实现模式为一个有效请求一个线程,客户端的I/O请求都是由OS先完成了再通知服务端应用去启动线程进行处理。
AIO
异步非阻塞,基于NIO的,可以称之为NIO2.0
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