I/O 模型基本说明
I/O 模型:就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收,很大程度上决定了程序通信的性能,Java 共支持 3 种网络编程的/IO 模型:BIO、NIO、AIO
Java BIO
- BIO(blocking I/O) : 同步阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,可以通过线程池机制改善(实现多个客户连接服务器).
简单示意图:
Java BIO 工作机制
- 服务器端启动一个 ServerSocket,注册端口,调用accpet方法监听客户端的Socket连接。
- 客户端启动 Socket 对服务器进行通信,默认情况下服务器端需要对每个客户 建立一个线程与之通讯
BIO模式下接收单客户端
客户端代码如下:
/**
目标: Socket网络编程。
功能1:客户端可以反复发消息,服务端可以反复收消息
小结:
通信是很严格的,对方怎么发你就怎么收,对方发多少你就只能收多少!!
*/
public class ClientDemo {
public static void main(String[] args) throws Exception {
System.out.println("==客户端的启动==");
// (1)创建一个Socket的通信管道,请求与服务端的端口连接。
Socket socket = new Socket("127.0.0.1",8888);
// (2)从Socket通信管道中得到一个字节输出流。
OutputStream os = socket.getOutputStream();
// (3)把字节流改装成自己需要的流进行数据的发送
PrintStream ps = new PrintStream(os);//这行代码将字节输出流转换为PrintStream对象。PrintStream类提供了方便的方法,可以将数据以字符串形式打印到输出流中。
// (4)开始发送消息
Scanner sc = new Scanner(System.in);
while(true){
System.out.print("请说:");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
}
}
服务端代码:
/**
* 服务端
*/
public class ServerDemo {
public static void main(String[] args) throws Exception {
System.out.println("==服务器的启动==");
//(1)注册端口
ServerSocket serverSocket = new ServerSocket(8888);
//(2)开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
Socket socket = serverSocket.accept();
//(3)从Socket管道中得到一个字节输入流。
InputStream is = socket.getInputStream();
//(4)把字节输入流包装成自己需要的流进行数据的读取(字符流)。
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//(5)读取数据
String line ;
while((line = br.readLine())!=null){
System.out.println("服务端收到:"+line);
}
}
}
小结
:实现单客户端多发,服务端只能处理一个客户端的请求,因为服务端是单线程的。一次只能与一个客户端进行消息通信。
BIO模式下接收多客户端
客户端代码如下:
/**
目标: Socket网络编程。
功能1:客户端可以反复发,一个服务端可以接收无数个客户端的消息!!
小结:
服务器如果想要接收多个客户端,那么必须引入线程,一个客户端一个线程处理!!
*/
public class ClientDemo {
public static void main(String[] args) throws Exception {
System.out.println("==客户端的启动==");
// (1)创建一个Socket的通信管道,请求与服务端的端口连接。
Socket socket = new Socket("127.0.0.1",7777);
// (2)从Socket通信管道中得到一个字节输出流。
OutputStream os = socket.getOutputStream();
// (3)把字节流改装成自己需要的流进行数据的发送
PrintStream ps = new PrintStream(os);
// (4)开始发送消息
Scanner sc = new Scanner(System.in);
while(true){
System.out.print("请说:");
String msg = sc.nextLine();
ps.println(msg);
ps.flush();
}
}
}
服务端代码:
/**
服务端
*/
public class ServerDemo {
public static void main(String[] args) throws Exception {
System.out.println("==服务器的启动==");
// (1)注册端口
ServerSocket serverSocket = new ServerSocket(7777);
while(true){
//(2)开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道
Socket socket = serverSocket.accept();
new ServerReadThread(socket).start();
System.out.println(socket.getRemoteSocketAddress()+"上线了!");
}
}
}
class ServerReadThread extends Thread{
private Socket socket;
public ServerReadThread(Socket socket){
this.socket = socket;
}
@Override
public void run() {
try{
//(3)从Socket管道中得到一个字节输入流。
InputStream is = socket.getInputStream();
//(4)把字节输入流包装成自己需要的流进行数据的读取。
BufferedReader br = new BufferedReader(new InputStreamReader(is));
//(5)读取数据
String line ;
while((line = br.readLine())!=null){
System.out.println("服务端收到:"+socket.getRemoteSocketAddress()+":"+line);
}
}catch (Exception e){
System.out.println(socket.getRemoteSocketAddress()+"下线了!");
}
}
}
小结
:
- 1.每个Socket接收到,都会创建一个线程,线程的竞争、切换上下文影响性能;
- 2.每个线程都会占用栈空间和CPU资源;
- 3.并不是每个socket都进行IO操作,无意义的线程处理;
- 4.客户端的并发访问增加时。服务端将呈现1:1的线程开销,访问量越大,系统将发生线程栈溢出,线程创建失败,最终导致进程宕机或者僵死,从而不能对外提供服务。
伪异步I/O编程
概述
在上述案例中:客户端的并发访问增加时。服务端将呈现1:1的线程开销,访问量越大,系统将发生线程栈溢出,线程创建失败,最终导致进程宕机或者僵死,从而不能对外提供服务。
采用一个伪异步I/O的通信框架,采用线程池和任务队列实现,当客户端接入时,将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程,对消息队列中Socket任务进行处理,由于线程池可以设置消息队列的大小和最大线程数,因此,它的资源占用是可控的,无论多少个客户端并发访问,都不会导致资源的耗尽和宕机。
客户端代码如下:
public class Client {
public static void main(String[] args) {
try {
// 1.建立一个与服务端的Socket对象:套接字
Socket socket = new Socket("127.0.0.1", 9999);
// 2.从socket管道中获取一个输出流,写数据给服务端
OutputStream os = socket.getOutputStream() ;
// 3.把输出流包装成一个打印流
PrintWriter pw = new PrintWriter(os);
// 4.反复接收用户的输入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line = null ;
while((line = br.readLine()) != null){
pw.println(line);
pw.flush();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
线程池代码:
// 线程池处理类
public class HandlerSocketThreadPool {
// 线程池
private ExecutorService executor;
public HandlerSocketThreadPool(int maxPoolSize, int queueSize){
this.executor = new ThreadPoolExecutor(
3, // 8
maxPoolSize,
120L,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(queueSize) );
}
public void execute(Runnable task){
this.executor.execute(task);
}
}
服务端代码:
public class Server {
public static void main(String[] args) {
try {
System.out.println("----------服务端启动成功------------");
ServerSocket ss = new ServerSocket(9999);
// 一个服务端只需要对应一个线程池
HandlerSocketThreadPool handlerSocketThreadPool =
new HandlerSocketThreadPool(3, 1000);
// 客户端可能有很多个
while(true){
Socket socket = ss.accept() ; // 阻塞式的!
System.out.println("有人上线了!!");
// 每次收到一个客户端的socket请求,都需要为这个客户端分配一个
// 独立的线程 专门负责对这个客户端的通信!!
handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class ReaderClientRunnable implements Runnable{
private Socket socket ;
public ReaderClientRunnable(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
// 读取一行数据
InputStream is = socket.getInputStream() ;
// 转成一个缓冲字符流
Reader fr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(fr);
// 一行一行的读取数据
String line = null ;
while((line = br.readLine())!=null){ // 阻塞式的!!
System.out.println("服务端收到了数据:"+line);
}
} catch (Exception e) {
System.out.println("有人下线了");
}
}
}
小结
:
- 伪异步io采用了线程池实现,因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题,但由于底层依然是采用的同步阻塞模型,因此无法从根本上解决问题。
- 如果单个消息处理的缓慢,或者服务器线程池中的全部线程都被阻塞,那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝,客户端会发生大量连接超时。