天凡建设股份有限公司网站,二维码生成器推荐,seo排名外包,网站分享对联广告前言#xff1a;
小弟能力不足#xff0c;认知有限#xff0c;难免考虑不全面#xff0c;希望大佬能给出更好的建议#xff0c;指出存在的问题和不足#xff0c;在此跪谢。
IO发展史
Java中对于I/O能力的支持主要分为三个比较关键的阶段#xff1a;
BIO
第一个阶段…前言
小弟能力不足认知有限难免考虑不全面希望大佬能给出更好的建议指出存在的问题和不足在此跪谢。
IO发展史
Java中对于I/O能力的支持主要分为三个比较关键的阶段
BIO
第一个阶段是起步阶段JDK1.0 ~ JDK1.3,这个阶段JDK是处于BIO阶段的也就是同步阻塞模式该阶段的类库还非常的初级对系统层面的一些网络编程的API都没有进行实现因此这个阶段的很多大型应用服务器都采用C或者C语言来进行开发的因为C或者C可以直接调用操作系统提供的非阻塞I/O能力
NIO
第二个阶段从JDK1.4开始的从JDK1.4开始Java新增了java.nio的包正式支持的NIO提供了许多非阻塞I/O开发的API和类库
AIO
第三个阶段是从JDK1.7开始的这一次是对原来的NIO类库进行了升级官方称为NIO 2.0该版本不但强化了原来的基于I/O多路复用模型的NIO模式同时新增了异步的AIO功能所以也有很多人称之为AIO。
各个IO介绍
BIO
在Java中BIOBlocking I/O指的是阻塞式I/O是一种基本的I/O模型。它的实现原理相对简单但在高并发场景下性能较差。下面我将详细介绍BIO的实现原理。 阻塞式I/O 在BIO中当一个线程在进行I/O操作时如果数据没有准备好该线程会被阻塞直到数据准备好并被读取或写入。这意味着一个线程只能处理一个连接如果有大量连接同时到来就需要大量线程来处理这会导致资源消耗过大。 实现原理 服务端服务端通过ServerSocket监听客户端的连接请求。当有连接请求到来时服务端会创建一个新的线程来处理该连接。客户端客户端通过Socket向服务端发起连接请求。一旦连接建立客户端和服务端之间可以进行数据的读取和写入。 服务端示例代码 思路在服务端的代码中我们创建了一个固定大小的线程池用于处理客户端的连接请求。每当有客户端连接时就会将连接交给线程池中的一个线程来处理这样可以提高并发处理能力。同时我们定义了一个ClientHandler类来处理客户端的请求这样可以更好地组织代码逻辑。 这样的设计可以更好地满足企业级生产环境的要求提高了系统的并发处理能力和稳定性。当然你还可以加入日志打印更好的排查问题但是因为这种已经过时所以只是简单示例。 import java.io.*;
import java.net.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Server {public static void main(String[] args) {ServerSocket serverSocket null;ExecutorService executor Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池try {serverSocket new ServerSocket(8080);System.out.println(Server started. Waiting for client...);while (true) {// 等待客户端连接Socket clientSocket serverSocket.accept();System.out.println(Client connected: clientSocket.getRemoteSocketAddress());// 使用线程池处理客户端请求executor.execute(new ClientHandler(clientSocket));}} catch (IOException e) {e.printStackTrace();} finally {try {if (serverSocket ! null) {serverSocket.close();}executor.shutdown(); // 关闭线程池} catch (IOException e) {e.printStackTrace();}}}private static class ClientHandler implements Runnable {private Socket clientSocket;public ClientHandler(Socket clientSocket) {this.clientSocket clientSocket;}Overridepublic void run() {try {// 获取输入流BufferedReader input new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));// 获取输出流PrintWriter output new PrintWriter(clientSocket.getOutputStream(), true);// 读取客户端发送的数据String clientMessage input.readLine();System.out.println(Received from client: clientMessage);// 向客户端发送数据output.println(Hello, client!);// 关闭流和连接input.close();output.close();clientSocket.close();} catch (IOException e) {e.printStackTrace();}}}
} 客户端实例代码实现 import java.io.*;
import java.net.*;public class Client {public static void main(String[] args) {Socket socket null;try {socket new Socket(localhost, 8080);System.out.println(Connected to server.);// 获取输入流BufferedReader input new BufferedReader(new InputStreamReader(socket.getInputStream()));// 获取输出流PrintWriter output new PrintWriter(socket.getOutputStream(), true);// 向服务端发送数据output.println(Hello, server!);// 读取服务端发送的数据String serverMessage input.readLine();System.out.println(Received from server: serverMessage);// 关闭流和连接input.close();output.close();socket.close();} catch (IOException e) {e.printStackTrace();} finally {try {if (socket ! null) {socket.close();}} catch (IOException e) {e.printStackTrace();}}}
} 适用场景 BIO适用于连接数较少且吞吐量要求不高的场景例如传统的Socket通信应用。 局限性 由于BIO的阻塞特性它在高并发场景下表现较差因为大量线程会因为I/O阻塞而处于等待状态导致资源浪费。
总的来说BIO是一种简单直观的I/O模型但在高并发场景下存在性能瓶颈。随着业务的发展通常会选择更高效的NIONon-blocking I/O或者AIOAsynchronous I/O来替代BIO。
NIO
在Java中NIONew I/O是一种非阻塞I/O模型相比于传统的BIOBlocking I/ONIO具有更高的并发处理能力。下面我将详细介绍NIO的实现原理。 非阻塞I/O NIO的核心是非阻塞I/O它允许一个线程处理多个连接当一个连接上的I/O操作不可立即完成时线程可以去处理其他连接而不是被阻塞。 核心组件 通道Channel用于读取和写入数据可以是文件、套接字等。缓冲区Buffer用于临时存储数据读取数据到缓冲区或将缓冲区中的数据写入通道。选择器Selector用于监听多个通道的事件例如连接就绪、读就绪、写就绪等。 实现原理 服务端服务端通过ServerSocketChannel监听连接请求一旦有连接到来会将该连接注册到Selector上并监听连接就绪事件。客户端客户端通过SocketChannel向服务端发起连接请求连接建立后也会注册到Selector上。 NIO服务器端示例代码 实现思路 在以下代码中我们引入了日志打印服务使用了Java自带的Logger类来记录日志。同时我们使用了线程池来处理客户端的连接请求和数据读写操作以提高并发处理能力。对于各种可能遇到的问题比如连接超时、网络异常、数据读写异常等我们在相应的位置进行了异常处理并记录了相应的日志以便于排查和解决问题。 这样的设计更加符合企业级生产规范提高了系统的并发处理能力和稳定性并且对各种异常情况进行了处理使得系统更加健壮可靠。 import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;public class NIOServer {private static final Logger logger Logger.getLogger(NIOServer.class.getName());private static final ExecutorService executor Executors.newFixedThreadPool(10);public static void main(String[] args) {try {Selector selector Selector.open();ServerSocketChannel serverSocketChannel ServerSocketChannel.open();serverSocketChannel.socket().bind(new InetSocketAddress(8080));serverSocketChannel.configureBlocking(false);serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);while (true) {selector.select();SetSelectionKey selectedKeys selector.selectedKeys();IteratorSelectionKey keyIterator selectedKeys.iterator();while (keyIterator.hasNext()) {SelectionKey key keyIterator.next();keyIterator.remove();if (key.isAcceptable()) {executor.execute(() - handleAccept(key, selector));} else if (key.isReadable()) {executor.execute(() - handleRead(key));}}}} catch (IOException e) {logger.severe(Error in NIO server: e.getMessage());}}private static void handleAccept(SelectionKey key, Selector selector) {try {ServerSocketChannel serverSocketChannel (ServerSocketChannel) key.channel();SocketChannel clientChannel serverSocketChannel.accept();clientChannel.configureBlocking(false);clientChannel.register(selector, SelectionKey.OP_READ);} catch (IOException e) {logger.severe(Error in handleAccept: e.getMessage());}}private static void handleRead(SelectionKey key) {try {SocketChannel clientChannel (SocketChannel) key.channel();ByteBuffer buffer ByteBuffer.allocate(1024);int bytesRead clientChannel.read(buffer);if (bytesRead -1) {clientChannel.close();key.cancel();} else if (bytesRead 0) {buffer.flip();byte[] data new byte[bytesRead];buffer.get(data);logger.info(Received from client: new String(data));// 可以在这里处理接收到的数据}} catch (IOException e) {logger.severe(Error in handleRead: e.getMessage());}}
} NIO客户端的代码 import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;public class NIOClient {private static final Logger logger Logger.getLogger(NIOClient.class.getName());private static final ExecutorService executor Executors.newFixedThreadPool(10);public static void main(String[] args) {try {SocketChannel socketChannel SocketChannel.open();socketChannel.configureBlocking(false);socketChannel.connect(new InetSocketAddress(localhost, 8080));while (!socketChannel.finishConnect()) {// 等待连接完成}executor.execute(() - {try {String message Hello, server!;ByteBuffer buffer ByteBuffer.wrap(message.getBytes());socketChannel.write(buffer);buffer.clear();int bytesRead socketChannel.read(buffer);if (bytesRead 0) {buffer.flip();byte[] data new byte[bytesRead];buffer.get(data);logger.info(Received from server: new String(data));// 可以在这里处理接收到的数据}} catch (IOException e) {logger.severe(Error in NIO client: e.getMessage());} finally {try {socketChannel.close();} catch (IOException e) {logger.severe(Error in closing socket channel: e.getMessage());}}});} catch (IOException e) {logger.severe(Error in NIO client: e.getMessage());}}
} 适用场景 NIO适用于高并发的网络应用例如Web服务器、聊天服务器等能够更高效地处理大量连接。
总的来说NIO通过Selector、Channel和Buffer的组合实现了非阻塞I/O提高了系统的并发处理能力。然而NIO编程相对复杂需要处理事件的就绪状态因此在实际应用中通常会使用NIO框架或者基于NIO的高级框架如Netty。
AIO
在Java中AIOAsynchronous I/O是一种基于事件和回调机制的I/O模型相比于传统的BIOBlocking I/O和NIONon-blocking I/OAIO更加适用于处理大量并发连接。下面我将详细介绍AIO的实现原理。 异步I/O AIO的核心是异步I/O它允许一个线程在等待数据就绪的同时继续做其他事情当数据就绪后通过回调机制来处理数据。这种模型相比于NIO更加灵活因为不需要手动检查就绪状态而是通过事件通知来处理。 核心组件 异步通道AsynchronousChannel用于进行异步I/O操作包括文件和套接字等。异步操作结果AsynchronousResult用于存储异步操作的结果可以通过回调方式获取结果。异步处理器AsynchronousHandler用于处理异步操作完成后的回调。 实现原理 服务端服务端通过AsynchronousServerSocketChannel监听连接请求一旦有连接到来会调用accept方法并通过回调方式处理连接就绪事件。客户端客户端通过AsynchronousSocketChannel向服务端发起连接请求连接建立后也可以通过回调方式处理后续的读写操作。 简单的AIO服务器示例代码 实现思路针对企业级生产环境中高可用的通信需求以下是一个更完善的AIO服务端和客户端的Java代码。该代码考虑了各种可能遇到的问题并给出了切实可行的异常解决方案。同时引入了日志打印服务使用了Java自带的Logger类来记录日志并使用了线程池来处理客户端的连接请求和数据读写操作以提高并发处理能力。 import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;public class AIOServer {private static final Logger logger Logger.getLogger(AIOServer.class.getName());private static final ExecutorService executor Executors.newFixedThreadPool(10);public static void main(String[] args) {try {AsynchronousServerSocketChannel serverSocketChannel AsynchronousServerSocketChannel.open();serverSocketChannel.bind(new InetSocketAddress(8080));serverSocketChannel.accept(null, new CompletionHandlerAsynchronousSocketChannel, Void() {Overridepublic void completed(AsynchronousSocketChannel clientChannel, Void attachment) {serverSocketChannel.accept(null, this); // 接受下一个连接executor.execute(() - handleRead(clientChannel));}Overridepublic void failed(Throwable exc, Void attachment) {logger.severe(Error in accepting connection: exc.getMessage());}});// 阻止主线程退出Thread.currentThread().join();} catch (IOException | InterruptedException e) {logger.severe(Error in AIO server: e.getMessage());}}private static void handleRead(AsynchronousSocketChannel clientChannel) {ByteBuffer buffer ByteBuffer.allocate(1024);clientChannel.read(buffer, null, new CompletionHandlerInteger, Void() {Overridepublic void completed(Integer bytesRead, Void attachment) {if (bytesRead -1) {try {clientChannel.close();} catch (IOException e) {logger.severe(Error in closing client channel: e.getMessage());}return;}buffer.flip();byte[] data new byte[bytesRead];buffer.get(data);logger.info(Received from client: new String(data));// 可以在这里处理接收到的数据buffer.clear();clientChannel.read(buffer, null, this); // 继续读取数据}Overridepublic void failed(Throwable exc, Void attachment) {logger.severe(Error in reading from client: exc.getMessage());}});}
} 简单的AIO客户端示例代码 import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;public class AIOClient {private static final Logger logger Logger.getLogger(AIOClient.class.getName());private static final ExecutorService executor Executors.newFixedThreadPool(10);public static void main(String[] args) {try {AsynchronousSocketChannel socketChannel AsynchronousSocketChannel.open();socketChannel.connect(new InetSocketAddress(localhost, 8080), null, new CompletionHandlerVoid, Void() {Overridepublic void completed(Void result, Void attachment) {String message Hello, server!;ByteBuffer buffer ByteBuffer.wrap(message.getBytes());socketChannel.write(buffer, null, new CompletionHandlerInteger, Void() {Overridepublic void completed(Integer bytesWritten, Void attachment) {if (buffer.hasRemaining()) {socketChannel.write(buffer, null, this); // 继续写入数据} else {buffer.clear();socketChannel.read(buffer, null, new CompletionHandlerInteger, Void() {Overridepublic void completed(Integer bytesRead, Void attachment) {buffer.flip();byte[] data new byte[bytesRead];buffer.get(data);logger.info(Received from server: new String(data));// 可以在这里处理接收到的数据}Overridepublic void failed(Throwable exc, Void attachment) {logger.severe(Error in reading from server: exc.getMessage());}});}}Overridepublic void failed(Throwable exc, Void attachment) {logger.severe(Error in writing to server: exc.getMessage());}});}Overridepublic void failed(Throwable exc, Void attachment) {logger.severe(Error in connecting to server: exc.getMessage());}});// 阻止主线程退出Thread.currentThread().join();} catch (IOException | InterruptedException e) {logger.severe(Error in AIO client: e.getMessage());}}
} 适用场景 AIO适用于需要处理大量并发连接且对性能要求较高的场景例如高性能的网络服务器、金融交易系统等。
总的来说AIO通过异步I/O和事件回调机制实现了高效的并发处理能力相比于NIO更加灵活和高效。然而AIO在Java中的实现相对较新需要较高的技术要求因此在实际应用中通常会使用成熟的AIO框架或者基于AIO的高级框架。
在Java中有一些成熟的AIO框架或者基于AIO的高级框架它们提供了更加便捷和高效的异步I/O编程方式。以下是一些常用的框架 Netty Netty是一个基于NIO的高性能网络通信框架但它也提供了对AIO的支持。Netty的异步事件驱动模型和高度可定制的架构使得它成为构建高性能、可扩展的网络应用程序的理想选择。Netty提供了丰富的功能包括TCP/UDP传输、HTTP编解码、WebSocket支持等广泛应用于网络服务器、分布式系统等领域。 Grizzly Grizzly是一个基于NIO的高性能网络框架它提供了对AIO的支持并且具有高度可扩展性和灵活性。Grizzly可以用于构建高性能的Web服务器、应用服务器等网络应用。 Apache MINA Apache MINA是一个基于NIO的网络应用框架它提供了对AIO的支持并且具有良好的扩展性和灵活性。MINA可以用于构建各种类型的网络应用包括游戏服务器、即时通讯服务器等。
这些框架都提供了对AIO的封装和抽象简化了异步I/O编程的复杂性同时提供了丰富的功能和高性能的网络通信能力。在实际应用中选择合适的框架取决于具体的需求和项目背景但无论选择哪个框架都可以极大地简化异步I/O编程的复杂性提高开发效率和系统性能。
