首页 > 资讯 > 后端开发 > Python >Java IO网络模型实现解析

710

分享到

Java IO网络模型实现解析

Java IO网络模型 Java IO 2023-03-19 17:03:43 710人浏览安东尼

Python 官方文档：入门教程 => 点击学习

摘要

目录前言正文一. Bio二. Non Blocking IO三. IO多路复用四. NIO总结前言本篇文章会对Java中的网络IO模型的概念进行解释，并给出具体的Java代码实现

前言

本篇文章会对Java中的网络IO模型的概念进行解释，并给出具体的Java代码实现，主要涉及如下部分。

BIO（同步阻塞IO模型）的概念和Java编程实现；
Non Blocking IO（同步非阻塞IO模型）的概念和Java编程实现；
IO多路复用的概念；
NIO（New IO）的概念和Java编程实现。

在开始本篇文章内容之前，有一个简单的关于Socket的知识需要说明：在进行网络通信的时候，需要一对Socket，一个运行于客户端，一个运行于服务端，同时服务端还会有一个服务端Socket，用于监听客户端的连接。下图进行一个简单示意。

那么整个通信流程如下所示。

服务端运行后，会在服务端创建listen-socket，listen-socket会绑定服务端的ip和port，然后服务端进入监听状态；
客户端请求服务端时，客户端创建connect-socket，connect-socket描述了其要连接的服务端的listen-socket，然后connect-socket向listen-socket发起连接请求；
connect-socket与listen-socket成功连接后（TCP三次握手成功），服务端会为已连接的客户端创建一个代表该客户端的client-socket，用于后续和客户端进行通信；
客户端与服务端通过socket进行网络IO操作，此时就实现了客户端和服务端中的不同进程的通信。

需要知道的就是，在客户端与服务端通信的过程中，出现了三种socket，分别是。

listen-socket。是服务端用于监听客户端建立连接的socket；
connect-socket。是客户端用于连接服务端的socket；
client-socket。是服务端监听到客户端连接请求后，在服务端生成的与客户端连接的socket。

（注：上述中的socket，可以被称为套接字，也可以被称为文件描述符。）

正文

一. BIO

BIO，即同步阻塞IO模型。用户进程调用read时发起IO操作，此时用户进程由用户态转换到内核态，只有在内核态中将IO操作执行完后，才会从内核态切换回用户态，这期间用户进程会一直阻塞。

BIO示意图如下。

简单的BIO的Java编程实现如下。

服务端实现

public class BiOServer {

    public static void main(String[] args) throws IOException {
        // 创建listen-Socket
        ServerSocket listenSocket = new ServerSocket(8080);
        // 进入监听状态，是一个阻塞状态
        // 有客户端连接时从监听状态返回
        // 并创建代表这个客户端的client-socket
        Socket clientSocket = listenSocket.accept();
        // 获取client-socket输入流
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()));
        // 读取客户端发送的数据
        // 如果数据没准备好，会进入阻塞状态
        String data = bufferedReader.readLine();
        System.out.println(data);

        // 获取client-socket输出流
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(clientSocket.getOutputStream()));
        // 服务端向客户端发送数据
        bufferedWriter.write("来自服务端的返回数据\n");
        // 刷新流
        bufferedWriter.flush();
    }

}

客户端实现

public class Bioclient {

    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 8080;

    public static void main(String[] args) throws IOException {
        // 客户端创建connect-socket
        Socket connectSocket = new Socket(SERVER_IP, SERVER_PORT);
        // 获取connect-socket输出流
        BufferedWriter bufferedWriter = new BufferedWriter(
                new OutputStreamWriter(connectSocket.getOutputStream()));
        // 客户端向服务端发送数据
        bufferedWriter.write("来自客户端的请求数据\n");
        // 刷新流
        bufferedWriter.flush();

        // 获取connect-socket输入流
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(connectSocket.getInputStream()));
        // 读取服务端发送的数据
        String returnData = bufferedReader.readLine();
        System.out.println(returnData);
    }

}

BIO的问题就在于服务端在accept时是阻塞的，并且在主线程中，一次只能accept一个Socket，accept到Socket后，读取客户端数据时又是阻塞的。

二. Non Blocking IO

Non Blocking IO，即同步非阻塞IO。是用户进程调用read时，用户进程由用户态转换到内核态后，此时如果没有系统资源数据能够被读取到内核缓冲区中，返回read失败，并从内核态切换回用户态。也就是用户进程发起IO操作后会立即得到一个操作结果。

Non Blocking IO示意图如下所示。

简单的Non Blocking IO的Java编程实现如下。

public class NonbioServer {

    public static final List&lt;SocketChannel&gt; clientSocketChannels = new ArrayList&lt;&gt;();

    public static void main(String[] args) throws Exception {
        // 客户端创建listen-socket管道
        // 管道支持非阻塞模式和同时读写
        ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
        // 设置为非阻塞模式
        listenSocketChannel.configureBlocking(false);
        // 绑定监听的端口号
        listenSocketChannel.socket().bind(new InetSocketAddress(8080));
        // 在子线程中遍历clientSocketChannels并读取客户端数据
        handleSocketChannels();

        while (true) {
            // 非阻塞方式监听客户端连接
            // 如果无客户端连接则返回空
            // 有客户端连接则创建代表这个客户端的client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            if (clientSocketChannel != null) {
                // 设置为非阻塞模式
                clientSocketChannel.configureBlocking(false);
                // 添加到clientSocketChannels中
                // 用于子线程遍历并读取客户端数据
                clientSocketChannels.add(clientSocketChannel);
            } else {
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        }
    }

    public static void handleSocketChannels() {
        new Thread(() -&gt; {
            while (true) {
                // 遍历每一个client-socket管道
                Iterator&lt;SocketChannel&gt; iterator = clientSocketChannels.iterator();
                while (iterator.hasNext()) {
                    SocketChannel clientSocketChannel = iterator.next();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                    int read = 0;
                    try {
                        // 将客户端发送的数据读取到ByteBuffer中
                        // 这一步的操作也是非阻塞的
                        read = clientSocketChannel.read(byteBuffer);
                    } catch (IOException e) {
                        // 移除发生异常的client-socket管道
                        iterator.remove();
                        e.printStackTrace();
                    }
                    if (read == 0) {
                        System.out.println("客户端数据未就绪");
                    } else {
                        System.out.println("客户端数据为：" + new String(byteBuffer.array()));
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        }).start();
    }

}

上述是Non Blocking IO的一个简单服务端的实现，相较于BIO，服务端在accept时是非阻塞的，在读取客户端数据时也是非阻塞的，但是还是存在如下问题。

一次只能accept一个Socket；
需要在用户进程中遍历所有的SocketChannel并调用read() 方法获取客户端数据，此时如果客户端数据未准备就绪，那么这一次的read() 操作的开销就是浪费的。

三. IO多路复用

在上述的BIO和Non Blocking IO中，一次系统调用，只会获取一个IO的状态，而如果采取IO多路复用机制，则可以一次系统调用获取多个IO的状态。

也就是获取多个IO的状态可以复用一次系统调用。

最简单的IO多路复用方式是基于select模型实现，步骤如下。

在用户进程中将需要监控的IO文件描述符（Socket）注册到IO多路复用器中；
执行select操作，此时用户进程由用户态转换到内核态（一次系统调用），然后在内核态中会轮询注册到IO多路复用器中的IO是否准备就绪，并得到所有准备就绪的IO的文件描述符列表，最后返回这些文件描述符列表；
用户进程在select操作返回前会一直阻塞，直至select操作返回，此时用户进程就获得了所有就绪的IO的文件描述符列表；
用户进程获得了就绪的IO的文件描述符列表后，就可以对这些IO进行相应的操作了。

换言之，IO多路复用中，只需要一次系统调用，IO多路复用器就可以告诉用户进程，哪些IO已经准备就绪可以进行操作了，而如果不采用IO多路复用，则需要用户进程自己遍历每个IO并调用accept() 或者read() 方法去判断，且一次accept() 或者read() 方法调用只能判断一个IO。

四. NIO

NIO，即New IO。关于NIO，有如下三大组件。

channel（管道）。介于buffer（字节缓冲区）和Socket（套接字）之间，用于数据的读写操作；
buffer（字节缓冲区）。是用户程序和channel（管道）之间进行读写数据的中间区域；
selector（IO多路复用器）。服务端的listen-socket和client-socket，客户端的connect-socket，都可以注册在selector上，注册的时候还需要指定监听的事件，比如为listen-socket指定监听的事件为ACCEPT事件，该事件发生则表示客户端建立了连接，还比如为client-socket指定监听的事件为READ事件，该事件发生则表示客户端发送的数据已经可读。

NIO的代码实现如下所示。

服务端实现

public class NioServer {

    private static Selector selector;

    public static void main(String[] args) {

        try {
            // 开启并得到多路复用器
            selector = Selector.open();
            // 服务端创建listen-socket管道
            ServerSocketChannel listenSocketChannel = ServerSocketChannel.open();
            // 设置为非阻塞模式
            listenSocketChannel.configureBlocking(false);
            // 为管道绑定端口
            listenSocketChannel.socket().bind(new InetSocketAddress(8080));
            // 将listen-socket管道注册到多路复用器上，并指定监听ACCEPT事件
            listenSocketChannel.reGISter(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                // 获取发生的事件，这个操作是阻塞的
                selector.select();
                // 拿到有事件发生的SelectionKey集合
                // SelectionKey表示管道与多路复用器的绑定关系
                Set&lt;SelectionKey&gt; selectionKeys = selector.selectedKeys();
                // 遍历每个发生的事件，然后判断事件类型
                // 根据事件类型，进行不同的处理
                Iterator&lt;SelectionKey&gt; iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isAcceptable()) {
                        // 处理客户端连接事件
                        handlerAccept(selectionKey);
                    } else if (selectionKey.isReadable()) {
                        // 处理客户端数据可读事件
                        handlerRead(selectionKey);
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerAccept(SelectionKey selectionKey) {
        // 从事件中获取到listen-socket管道
        ServerSocketChannel listenSocketChannel = (ServerSocketChannel) selectionKey.channel();
        try {
            // 为连接的客户端创建client-socket管道
            SocketChannel clientSocketChannel = listenSocketChannel.accept();
            // 设置为非阻塞模式
            clientSocketChannel.configureBlocking(false);
            // 将client-socket管道注册到多路复用器上，并指定监听READ事件
            clientSocketChannel.register(selector, SelectionKey.OP_READ);
            // 给客户端发送数据
            clientSocketChannel.write(ByteBuffer.wrap("连接已建立\n".getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerRead(SelectionKey selectionKey) {
        // 从事件中获取到client-socket管道
        SocketChannel clientSocketChannel = (SocketChannel) selectionKey.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 读取客户端数据
            int read = clientSocketChannel.read(byteBuffer);
            if (read &lt;= 0) {
                // 关闭管道
                clientSocketChannel.close();
                // 从多路复用器移除绑定关系
                selectionKey.cancel();
            } else {
                System.out.println(new String(byteBuffer.array()));
            }
        } catch (IOException e1) {
            try {
                // 关闭管道
                clientSocketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            // 从多路复用器移除绑定关系
            selectionKey.cancel();
            e1.printStackTrace();
        }
    }

}

客户端实现

public class NioClient {

    private static Selector selector;

    public static final String SERVER_IP = "127.0.0.1";
    public static final int SERVER_PORT = 8080;

    public static void main(String[] args) {
        try {
            // 开启并得到多路复用器
            selector = Selector.open();
            // 创建connect-socket管道
            SocketChannel connectSocketChannel = SocketChannel.open();
            // 设置为非阻塞模式
            connectSocketChannel.configureBlocking(false);
            // 设置服务端IP和端口
            connectSocketChannel.connect(new InetSocketAddress(SERVER_IP, SERVER_PORT));
            // 将connect-socket管道注册到多路复用器上，并指定监听CONNECT事件
            connectSocketChannel.register(selector, SelectionKey.OP_CONNECT);

            while (true) {
                // 获取发生的事件，这个操作是阻塞的
                selector.select();
                // 拿到有事件发生的SelectionKey集合
                // SelectionKey表示管道与多路复用器的绑定关系
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                // 遍历每个发生的事件，然后判断事件类型
                // 根据事件类型，进行不同的处理
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    iterator.remove();
                    if (selectionKey.isConnectable()) {
                        // 处理连接建立事件
                        handlerConnect(selectionKey);
                    } else if (selectionKey.isReadable()) {
                        // 处理服务端数据可读事件
                        handlerRead(selectionKey);
                    }
                }
                LockSupport.parkNanos(1000 * 1000 * 1000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handlerConnect(SelectionKey selectionKey) throws IOException {
        // 拿到connect-socket管道
        SocketChannel connectSocketChannel = (SocketChannel) selectionKey.channel();
        if (connectSocketChannel.isConnectionPending()) {
            connectSocketChannel.finishConnect();
        }
        // 设置为非阻塞模式
        connectSocketChannel.configureBlocking(false);
        // 将connect-socket管道注册到多路复用器上，并指定监听READ事件
        connectSocketChannel.register(selector, SelectionKey.OP_READ);
        // 向服务端发送数据
        connectSocketChannel.write(ByteBuffer.wrap("客户端发送的数据\n".getBytes()));
    }

    private static void handlerRead(SelectionKey selectionKey) {
        // 拿到connect-socket管道
        SocketChannel connectSocketChannel = (SocketChannel) selectionKey.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        try {
            // 读取服务端数据
            int read = connectSocketChannel.read(byteBuffer);
            if (read <= 0) {
                // 关闭管道
                connectSocketChannel.close();
                // 从多路复用器移除绑定关系
                selectionKey.cancel();
            } else {
                System.out.println(new String(byteBuffer.array()));
            }
        } catch (IOException e1) {
            try {
                // 关闭管道
                connectSocketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
            // 从多路复用器移除绑定关系
            selectionKey.cancel();
            e1.printStackTrace();
        }
    }

}

总结

本篇文章中所讨论的IO模型，都是同步IO模型，而何谓同步异步，何谓阻塞非阻塞，可以总结如下。

同步和异步。同步IO表示需要在用户进程中主动的去询问操作系统数据是否准备好，如果没有准备好，还需要持续的询问，直到数据准备好为止；而异步IO则是在用户进程中只需要询问操作系统一次，后续数据准备好后操作系统会主动的将数据给到用户进程；
阻塞和非阻塞。阻塞IO就是发起一次系统调用后，会一直阻塞直到有结果返回；而非阻塞IO就是发起一次系统调用后，会立即得到一个返回结果。

实际上在Java中是有对异步IO（AIO）做支持，但是AIO依赖操作系统的底层实现，而目前Linux对AIO的支持不成熟，所以AIO的使用并不多，像主流的网络应用框架Netty也都没有使用到AIO。

以上就是Java IO网络模型实现解析的详细内容，更多关于Java IO网络模型的资料请关注编程网其它相关文章！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java IO网络模型实现解析

本文链接: https://www.lsjlt.com/news/200247.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

回答

如何调试操作系统的错误？
操作系统

2023-11-15发布

回答

操作系统中的I/O系统是如何实现的？
操作系统

2023-11-15发布

回答

如何实现操作系统的内存管理？
操作系统

2023-11-15发布

回答

什么是虚拟内存，它对操作系统有什么影响？
操作系统

2023-11-15发布

回答

ASP中的MVC架构和WebForms架构有什么区别和使用场景？
ASP.NET

2023-11-15发布

回答

ASP中的数据验证和数据校验有什么不同？
ASP.NET

2023-11-15发布

回答

ASP中的ADO对象和DAO对象有什么区别和使用方法？
ASP.NET

2023-11-15发布

回答

Node.js中的包管理器NPM是什么？如何使用它进行依赖管理？
node.js

2023-11-15发布

回答

Vue.js中的动态组件是什么？如何使用它来动态渲染组件？
VUE

2023-11-15发布

回答

如何使用Vue.js实现懒加载和预加载？
VUE

2023-11-15发布

Java IO网络模型实现解析

目录

前言

正文

一. BIO

二. Non Blocking IO

三. IO多路复用

四. NIO

总结

本篇文章演示代码以及资料文档资料下载

Java IO网络模型实现解析

Java IO网络模型如何实现

解析Linux高性能网络IO和Reactor模型

Java IO模型与Java网络编程模型的对比

总结网络IO模型与select模型的Python实例讲解

Java IO篇之Reactor 网络模型的概念

Linux下的网络IO模型怎么理解

Java IO中Reactor网络模型的概念是什么

Java网络编程之IO模型阻塞与非阻塞简要分析

Linux高性能网络IO和Reactor模型的示例分析

BIO、NIO、IO多路复用模型详细介绍&Java NIO 网络编程

BIO、NIO、IO多路复用模型详细介绍&Java NIO 网络编程

Java网络编程之UDP实现原理解析

python神经网络Xception模型复现详解

python神经网络InceptionV3模型复现详解

python神经网络ShuffleNetV2模型复现详解

python神经网络Densenet模型复现详解

python神经网络Keras GhostNet模型的实现

python神经网络Inception ResnetV2模型复现详解

python神经网络MobileNetV2模型的复现详解

python分析数据的方法是什么

如何使用Python实现抽奖小程序

python copy函数的作用是什么

python进程池创建队列的方法是什么

python字符串处理与应用的方法有哪些

python全局变量如何定义

python如何读取文件夹下所有文件

python keyerror错误怎么解决

python如何提取字符串的数字

python中怎么将回车作为输入内容