BIO、NIO、AIO

最新推荐文章于 2024-07-26 21:10:05 发布

Happy编程

最新推荐文章于 2024-07-26 21:10:05 发布

阅读量659

点赞数

分类专栏：网络编程 java&web编程文章标签： java BIO NIO 网络编程

本文链接：https://blog.csdn.net/wanghaiping1993/article/details/124907695

版权

6、 NIO核心三：选择器(Selector)

7、 NIO非阻塞式网络通信原理分析（流程）

8、 NIO非阻塞式网络通信入门案例

9、 NIO 网络编程应用实例-群聊系统

第四章 AIO编程

第一章 IO演进之路

1.1、介绍

1、BIO

同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器

端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

2、NIO

同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注

册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理

3、AIO(NIO2.0)

异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

1.2、使用场景

1、BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。

2、NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4 开始支持。

3、AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。

第二章 JAVA BIO深入剖析

1、 Java BIO 基本介绍

Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io

BIO(blocking I/O) ：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需

要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).

2、 Java BIO 工作机制

1.服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。

2.客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯

3、BIO模式下多发和多收消息

客户端代码如下

Java

import java.io.OutputStream;

import java.io.PrintStream;

import java.net.Socket;

import java.util.Scanner;

/**

目标: 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);

// （4）开始发送消息

Scanner sc = new Scanner(System.in);

while(true){

System.out.print("请说:");

String msg = sc.nextLine();

ps.println(msg);

ps.flush();

}

服务端代码如下

Java

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.ServerSocket;

import java.net.Socket;

/**

* 服务端

public class ServerDemo {

public static void main(String[] args) throws Exception {

String s = "886";

System.out.println("886".equals(s));

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);

}

4、BIO模式下伪异步IO编程

在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

客户端源码分析

TypeScript

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();

}

线程池处理类

Java

// 线程池处理类

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);

}

服务端源码分析

TypeScript

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请求将被拒绝，客户端会发生大量连接超时。

第三章 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的比较

NIO	BIO
面向缓冲区（Buffer），数据以块的方式处理	面向流（Stream）
非阻塞（Non Blocking IO）	阻塞IO(Blocking IO)
选择器（Selectors