Java IO模型(BIO/NIO/IOM)原生代码手写

最新推荐文章于 2024-06-29 15:13:52 发布
置顶 最新推荐文章于 2024-06-29 15:13:52 发布
阅读量565 收藏
点赞数
分类专栏： # 深入理解Netty（分布式网络通信框架） # 中间件原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30056341/article/details/102730005
版权

                       Java IO模型(BIO/NIO/IOM)原生代码手写

原生BIO模型

package com.tcf.io.model.server.bio;

import java.net.ServerSocket;
import java.net.Socket;

/***
 * TODO TCF 阻塞IO-服务器
 * @author Hasee
 *
 */
public class ServerBIO {

    private static byte[] byteArray=new byte[1024];
    
    @SuppressWarnings("resource")
    public static void main(String[] args) 
    {
        try
        {
            //TODO TCF 打开Socket服务
            ServerSocket serverSocket=new ServerSocket(8080);
            
            //TODO TCF 获取客户端发送的消息
            System.out.println("开始接收客户端发送的消息...");
            Socket socket=serverSocket.accept();
            
            //TODO TCF 读取客户端发送的消息
            int readResult=socket.getInputStream().read(byteArray);
            if(readResult>0)
            {
                System.out.println("服务器接收到的消息："+new String(byteArray));
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

 

BIO多线程实现伪异步IO操作(基于ExecutorService线程池调度器)

package com.tcf.io.model.server.bio;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/***
 * TODO TCF 伪异步阻塞IO模型(BIO)-服务器
 * TODO TCF 基于多线程实现批量IO操作，一个客户端只能建立一次TCP
 * @author Hasee
 *
 */
public class ServerBIODisguiser {

    //TODO TCF 读取字节数
    private static byte[] byteArray=new byte[1024];
    
    //TODO TCF 线程池
    private static ExecutorService executorService=Executors.newCachedThreadPool();
    
    @SuppressWarnings("resource")
    public static void main(String[] args) 
    {
        try
        {
            //TODO TCF 建立连接
            final ServerSocket serverSocket=new ServerSocket(8080);
            
            System.out.println("开始接收客户端发送的消息...");
            
            while(true)
            {
                //TODO TCF 接收客户端发送的消息
                final Socket socket=serverSocket.accept();
                
                executorService.execute(new Runnable() {
                    
                    @Override
                    public void run() 
                    {
                        try 
                        {
                            int readResult=socket.getInputStream().read(byteArray);
                            if(readResult>0)
                            {
                                System.out.println("接收到客户端发送的消息："+new String(byteArray));
                            }
                        } 
                        catch (Exception e)
                        {
                            e.printStackTrace();
                        }
                    }
                    
                });
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
}

 

原生NIO模型

package com.tcf.io.model.server.nio;

import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

/****
 * TODO TCF 非阻塞IO模型-服务器
 * TODO TCF 单线程进行批量IO操作，不阻塞
 * @author Hasee
 *
 */
public class ServerNIO {

    //TODO TCF 输入流装载的字节缓冲区ByteBuffer
    private static ByteBuffer byteBuffer=ByteBuffer.allocate(512);
    
    public static void main(String[] args) 
    {
        try
        {
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            
            //TODO TCF 绑定服务器端口号
            serverSocketChannel.bind(new InetSocketAddress(8080));
            
            //TODO TCF 设置为非阻塞IO模型NIO
            serverSocketChannel.configureBlocking(false);
            
            //TODO TCF 接收客户端发送过来的消息
            System.out.println("开始接收客户端发送的消息...");
            SocketChannel socketChannel=serverSocketChannel.accept();
            
            if(socketChannel!=null)
            {
                //TODO TCF 接收到客户端发送的消息，直接输出
                int readResult=socketChannel.read(byteBuffer);
                
                if(readResult>0)
                {
                    //TODO TCF 字节缓冲区转字节
                    byte[] byteArray=byteBuffer.array();
                    
                    if(byteArray!=null && byteArray.length>0)
                    {
                        System.out.println("接收到客户端发送过来的消息："+new String(byteArray));
                    }
                }
            }
            else
            {
                //TODO TCF 没有接收到客户端发送的消息，直接输出未接收
                System.out.println("未接收到客户端发送过来的消息");
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
}
 

伪装NIO选择器实现NIO操作

package com.tcf.io.model.server.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;

/***
 * TODO TCF 基于NIO三要素：选择器Selector，自定义集合作为选择器，实现伪非阻塞IO模型
 * @author Hasee
 *
 */
public class ServerNIODisguiser {

    //TODO TCF 输入流存放的字节缓冲区ByteBuffer
    private static ByteBuffer byteBuffer=ByteBuffer.allocate(512);
    
    //TODO TCF 选择器Selector
    private static List<SocketChannel> selector=new ArrayList<SocketChannel>();
    
    public static void main(String[] args) 
    {
        try
        {
            //TODO TCF 创建NIO非阻塞IO服务
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            
            //TODO TCF 绑定运行端口
            serverSocketChannel.bind(new InetSocketAddress(8080));
            
            //TODO TCF 指定处理IO方式为非阻塞IO(NIO)
            serverSocketChannel.configureBlocking(false);
            
            //TODO TCF 获取接收到的客户端发送的消息
            System.out.println("开始接收客户端发送的消息...");
            
            while(true)
            {
                SocketChannel socketChannel=serverSocketChannel.accept();
                if(socketChannel!=null)
                {
                    //TODO TCF 接收到客户端发送的消息，存入选择器
                    // socketChannel.configureBlocking(false);
                    selector.add(socketChannel);
                    
                    //TODO TCF 遍历选择器并输出接收到的消息
                    for(SocketChannel channel:selector)
                    {
                        int readResult=channel.read(byteBuffer);
                        
                        if(readResult>0)
                        {
                            byteBuffer.flip();
                            
                            //TODO TCF 字节缓冲区转字节
                            byte[] byteArray=byteBuffer.array();
                            if(byteArray!=null && byteArray.length>0)
                            {
                                System.out.println("接收到客户端发送的消息："+new String(byteArray));
                            }
                        }
                    }
                }
                
                //TODO TCF 没有接收到消息则直接跳过，因为是非阻塞IO处理，不论是否接收到客户端发送的消息都不影响程序执行...
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
}
 

仿生实现JDK(1.4+版本)内置NIO选择器和通道处理

package com.tcf.io.model.server.nio;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/***
 * TODO TCF 基于JDK原生API实现非阻塞IO-NIO
 * @author Hasee
 *
 */
public class ServerNIOPro {

    //TODO TCF 选择器Selector，存放客户端发送的处理IO请求
    private Selector selector;
    
    //TODO TCF 初始化非阻塞IO模型服务器
    public void init(Integer port)
    {
        try
        {
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            
            //TODO TCF 绑定运行端口
            serverSocketChannel.bind(new InetSocketAddress(port.intValue()));
            
            //TODO TCF 设置处理IO的方式为非阻塞IO-NIO
            serverSocketChannel.configureBlocking(false);
            
            //TODO TCF 非阻塞IO选择器初始化
            this.selector=Selector.open();
            
            //TODO TCF 当前IO处理通道存入选择器
            serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    //TODO TCF 监听器，监听选择器中的每一个IO处理请求
    public void listen()
    {
        System.out.println("开始接收客户端发送的消息...");
        
        try
        {
            while(true)
            {
                //TODO TCF 选择器中通道元素数量
                int result=this.selector.select();
                
                if(result>0)
                {
                    //TODO TCF 获取选择器中的通道
                    Iterator<SelectionKey> iterator=this.selector.selectedKeys().iterator();
                    while(iterator.hasNext())
                    {
                        SelectionKey selectionKey=iterator.next();
                        
                        //TODO TCF 删除当前已经处理的通道
                        iterator.remove();
                        
                        //TODO TCF 如果通道事件类型是Accept则需要获取客户端发送的通道并重新加入选择器，返回ServerSocketChannel
                        //TODO TCF 如果通道事件类型是Read则直接获取通道数据输出，返回SocketChannel
                        if(selectionKey.isAcceptable())
                        {
                            //TODO TCF 接收到客户端发送的请求事件(accept)，获取客户端发送的消息通道(SocketChannel)，重新存入选择器
                            ServerSocketChannel serverSocketChannel=(ServerSocketChannel) selectionKey.channel();
                            
                            //TODO TCF 获取接收到客户端发送的消息
                            SocketChannel socketChannel=serverSocketChannel.accept();
                            
                            if(socketChannel!=null)
                            {
                                //TODO TCF 设置为非阻塞IO处理模式并重新加入选择器
                                socketChannel.configureBlocking(false);
                                
                                //TODO TCF 通道设置只读权限
                                socketChannel.register(selector,SelectionKey.OP_READ);
                            }
                        }
                        else if (selectionKey.isReadable()) 
                        {
                            //TODO TCF 如果通道是只读权限，直接获取通道数据并输出
                            SocketChannel socketChannel=(SocketChannel)selectionKey.channel();
                            
                            //TODO TCF 获取接收到的消息，存放字节缓冲区
                            ByteBuffer byteBuffer=ByteBuffer.allocate(512);
                            int readResult=socketChannel.read(byteBuffer);
                            
                            if(readResult>0)
                            {
                                byteBuffer.flip();
                                
                                //TODO TCF 字节缓冲区中的字节
                                byte[] byteArray=byteBuffer.array();
                                
                                if(byteArray!=null && byteArray.length>0)
                                {
                                    System.out.println("接收到客户端发送的消息："+new String(byteArray));
                                    
                                    //TODO TCF 响应客户端信息
                                    ByteBuffer responseByteBuffer=ByteBuffer.wrap(byteArray);
                                    socketChannel.write(responseByteBuffer);
                                }
                            }
                        }
                    }
                }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) 
    {
        ServerNIOPro serverNIOPro=new ServerNIOPro();
        serverNIOPro.init(8080);
        serverNIOPro.listen();
    }
    
}
 

基于Socket通信的客户端(基于TCP传输协议)

package com.tcf.io.model.client;

import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.Scanner;

import org.apache.commons.lang.StringUtils;

/***
 * TODO TCF 基于Socket通信-TCP协议客户端
 * @author Hasee
 *
 */
public class SocketTCPClient1 {

    //TODO TCF 输入流存放的字节数组
    private static byte[] byteArray=new byte[1024];
    
    public static void main(String[] args)
    {
        Socket socket=new Socket();
        SocketAddress address=new InetSocketAddress(8080);
        
        try
        {
            //TODO TCF 建立连接
            socket.connect(address);
            
            //TODO TCF 发送消息
            while(true)
            {
                Scanner input=new Scanner(System.in);
                String message=input.next();
                
                if(StringUtils.isNotEmpty(message))
                {
                    socket.getOutputStream().write(message.getBytes());
                    System.out.println("消息发送成功...");
                    
                    //TODO TCF 接收到服务器返回的响应数据
                    int responseResult=socket.getInputStream().read(byteArray);
                    if(responseResult>0)
                    {
                        System.out.println("接收到返回的响应数据："+new String(byteArray));
                    }
                }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    
}
 

程序员田宝宝
关注
专栏目录
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 1980
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
手写一个简化版的Tomcat（NIO版本）
撸起袖子加油干
02-08 293
一、摘要： 序号 实现方式 功能链接 1 BIO 手写一个简化版的Tomcat(BIO版本） 2 BIO-Plus 手写一个简化版的Tomcat（BIO升级版本） 3 NIO 手写一个简化版的Tomcat（NIO版本） 4 Netty 手写一个简化版的Tomcat（Netty版本） 二、demo编码 package com.jason.http.server.nio; import java.io.IOException
Java I/O 模型的演进
老卫的技术站
03-01 2061
什么是同步？什么是异步？阻塞和非阻塞又有什么区别？本文先从 Unix 的 I/O 模型讲起，介绍了5种常见的 I/O 模型。而后再引出 Java 的 I/O 模型的演进过程，并用实例说明如何选择合适的 Java I/O 模型来提高系统的并发量和可用性。
Java NIO基础：手写服务器逻辑解析
最新发布
m0_74022176的博客
06-29 327
以此为基础，将核心概念掌握再拓展，比如跨域问题，如何让服务器更加稳定等等。在Java中，NIO（New I/O）提供了一种基于通道（Channel）和选择器（Selector）的非阻塞I/O处理方式。今天，我们将基于Java NIO的基本概念，来解析一个简单的手写服务器逻辑。来监听传入的连接，并绑定到一个特定的IP地址和端口上。接着，我们将这个通道设置为非阻塞模式，以便在没有可用连接时，线程不会被阻塞。上有新的连接请求时，我们接受这个连接，并将新的。上，并指定我们关心的事件是新的连接请求（
Java NIO手写简易版tomcat
weixin_44371237的博客
01-03 273
采用NIO，只用Channel和ByteBuffer两大组件 //采用NIO，只用Channel和ByteBuffer两大组件 public class tomcat { public static final String SEPARATOR = "\r\n"; //源码注释：requested maximum length of the queue of incoming connections. //BACK_LOG影响的accept队列大小 public static
JavaNIO手写聊天室
whhwch1986的博客
02-20 217
服务端 package com.huwc.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class
手写一个NIO群聊系统
fyphome
02-07 1066
一、浅谈NIO 1. 什么是NIO? ​​Java NIO​​：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接)，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 ​​I/O​​ 请求就进行处理。【简单示意图】 手写的服务端，是利用多路复用的技术处理多个客户端的，类似于redis的单线程多路复用处理，有什么好处？比传统的BIO（Blocking I/O）处理速度更快，传统的BIO处理一个客户端，服务端得启动一个线程去处理，这个线程没法关心处理其他客户端，是1对1模式。 &nbs
Java文件读写IO/NIO及性能比较详细代码及总结
08-28
Java文件读写IO/NIO及性能比较详细代码及总结 Java文件读写是Java编程中一个非常重要的方面，在各种项目中都需要对文件进行读写操作。Java提供了多种方式来实现文件读写，包括字节读写、字符读取、行读取等。以下是...
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO 三种模型，并提供了完整的实例代码。 BIO（Blocking I/O） BIO 是传统的同步阻塞模型，服务器端使用 ServerSocket 监听客户端的连接请求，客户端...
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
压缩包中的文件可能包含了实现这三种通信模型的Java代码示例，通过学习和理解这些代码，你可以更好地掌握Java I/O的运用，并根据需求选择合适的模型。建议从简单的BIO开始，逐步过渡到更复杂的NIO和AIO，理解其工作...
Java基础：Java的IO流，IO、BIO、NIO、AIO
weixin_42188778的博客
05-01 686
一、背景。 这篇文章主要介绍了Java的IO流，IO、BIO、NIO、AIO详细教程,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下。放假在家里休息，闲来无事，想巩固巩固自己的基础知识。Java基础这个我会一直更新的，希望大家关注 收藏 点赞。 二、Java的IO流，IO、BIO、NIO、AIO。 1.java 中 IO 流分为几种? 1).按照流的流向分，可以分为输入流和输出流； 2).按照操作单元划分，可以划分为字节流和字符流；
手写 tomcat nio
01-22
手写 tomcat nio http://knight-black-bob.iteye.com/blog/2408450
自己手写nio和netty，不建议下载
04-01
自己手写nio和netty，不建议下载
手写JAVA NIO实现Socket通信及其过程中注意的问题
ccityzh的博客
07-26 2019
当然现在不需要自己手写NIO实现socket，都是在需要建立TCP/IP连接的程序中直接使用mina框架，或者netty框架， 后者使用的更多。本文仅仅是手写NIO，找一找学习NIO中遇到的问题，以及在调试的过程中学习对某些API的理解，文中只写了服务端，客户端用SocketTools这个工具充当，测试。
Java中IO模型-NIO模型
m0_46853673的博客
09-16 225
Java中IO模型-NIO模型 NIO的介绍 NIO(New IO)同步非阻塞IO模型，采用了事件驱动的思想来实现一个复用器，来解决大并发的问题 NIO中，将读、写、可连接、可接受等操作在BIO中是阻塞处理，将操作设置为非阻塞，并将这些操作视为事件，当关注某个事件时，将其注册到复用器Selector(本质上使用底层操作系统提供的IO复用器：（select、poll，epoll)。由系统来监听事件是否准备就绪， 当socket有读或者可写操作时，系统会通知相应的用户程序来处理，将流读取到缓冲区或者写入到系统中
第一章 Java的IO演进之路
weixin_30820077的博客
05-06 198
Unix中5种IO模型 　　就网络通信而言，一次数据读入可以分为两个阶段，首先等待数据从网络中到达，到达后需要复制到内核的缓冲区中，第二个阶段是从内核的缓冲区复制到进程的缓冲区，复制到进程的缓冲区才算读取完毕。推广到所有IO，一次完整的IO读入分为两个阶段 等待数据准备完毕 把准备好的数据读到进程的内存空间 　　各种IO模型的区别在于当一个进程读取的数据没有准备好的时候该...
Java IO模型
kyrielx的博客
08-28 471
详细介绍Java中支持的三种网络编程模型：BIO、NIO、AIO
JavaNIO模型
Zouch
07-01 363
先简单总结一下IO模型： 1. 阻塞IO模型 工作流程：用户线程发出IO请求，cpu内核检查返回数据是否就绪，此时用户线程一直处于阻塞状态。数据就绪后，内核将数据复制到用户线程中，并返回结果。 2. 非阻塞IO模型 工作流程：用户线程发出IO请求，cpu内核检查返回数据是否就绪，并返回。这个时候用户线程是非阻塞的，但是会不断询问内核数据处理结果。 3. 多路复用IO模型 在多路复用I/O模型中，会有一个被称为Selector的线程不断轮询多个Socket的状态，只有socket有读写事件时，才会通知用户线程
java——io模型
Field_ctxy的博客
03-30 375
javaio模型，bio，nio，零拷贝。io多路复用。
Java IO模型深度解析：BIO、NIO与AIO的差异与应用
"Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析" 在Java编程中，IO（Input/Output）模型是处理数据传输的关键部分，它决定了应用程序如何与硬件交互来读写数据。Java提供了三种主要的IO模型：BIO...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值