java网络IO的三种实现方式

最新推荐文章于 2024-03-05 14:57:45 发布
最新推荐文章于 2024-03-05 14:57:45 发布
阅读量3.9k 收藏 3
点赞数
分类专栏： Java 文章标签： java nio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cikezxy/article/details/78110634
版权
[toc]
#BIO---Blocking IO
- 每个socket一个线程，读写时线程处于阻塞状态。
优点：实现简单
缺点：无法满足高并发，高接入的需求
- 不使用线程池的BIO模型，除了无法满足高并发需求外，由于需要为每个请求创建一个线程，还可能因为接入大量不活跃连接而耗尽服务器资源。
- 使用线程池的BIO模型，虽然控制了线程数量，但由于其本质上读写仍是阻塞的，仍无法满足高并发需求。
   
#NIO---Non-Blocking IO（非阻塞IO）
##非阻塞IO和多路复用
非阻塞IO和多路复用实际上是两个不用的概念，由于两者通常结合在一起使用，因此两者往往被混为一谈。下面我将试着分清这两个概念：
###非阻塞IO
与BIO相对应，非阻塞IO的读写方法无论是否有数据都立即返回，因此可以通过轮询方式来实现，但轮询方式的效率并不比BIO有显著提高，因为每个连接仍然需要占用一个线程。下面是轮询方式实现的IO模式图：
###多路复用
- 多路复用结合非阻塞IO能够明显提高IO的效率，这也是Java1.4把非阻塞IO和多路复用同时发布的原因。
- 多路复用的核心是多路复用器(Selector)，它是需要操作系统底层支持的，简单的说，就是进程把多个socket和它们关心的事件（比如连接请求或数据已准备好）都注册在多路复用器上，操作系统会在事件发生时通知多路复用器，这样进程就可以通过多路复用器知道在那个socket上发生了什么时间，从而进行对应的处理。
- 多路复用的优点在于只需要一个线程监测（阻塞或轮询方式均可）多路选择器的状态，只有在有事件需要发生时才会真正的创建线程进行处理，因此更适合高并发多接入的应用环境。
 - 在Linux系统下，多路复用的底层实现是epoll方法，与select/poll的顺序扫描不同，epoll采用效率更高的事件驱动方式，而且epoll方式并没有socket个数限制。
##BIO和NIO的比较
- BIO适用于连接长期保持的应用，比如一个复杂系统中模块之间通过长连接来进行通信。
- NIO加多路复用的模式更适合短连接、高并发、多接入的情形，比如网络服务器。
##NIO网络编程的常用接口

##Reactor模式
Reactor模式用于解决事件分发处理的问题，Handler把自己的channel和关注的事件注册到Selector中，当对应的事件发生在自己的channel上时，对应的handler就会得到通知并进行处理。
- 单线程的Reactor
消息的分发、读写、处理都在一个线程中处理，是Reactor最简单的实现方式，如果消息的处理需要较长时间，会影响效率。
 
```java
//Reactor类，负责分发事件并调用对应的handler
class Reactor implements Runnable {  
    final Selector selector;
    final ServerSocketChannel serverSocket;

    //Reactor初始化
    Reactor(int port) throws IOException { 
        selector = Selector.open();
        serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(port));
        serverSocket.configureBlocking(false); //必须配置为非阻塞

        //Acceptor会在Reactor初始化时就注册到Selector中，用于接受connect请求
        SelectionKey sk = serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        sk.attach(new Acceptor()); //attach callback object, Acceptor
    }
     
    //分发消息并调用对应的handler
    public void run() { 
        try {
            while (!Thread.interrupted()) {
                selector.select();
                Set selected = selector.selectedKeys();
                Iterator it = selected.iterator();
                while (it.hasNext())
                    dispatch((SelectionKey)(it.next()); //Reactor负责dispatch收到的事件
                selected.clear();
            }
        } catch (IOException ex) { /* ... */ }
    }
     
    void dispatch(SelectionKey k) {
        Runnable r = (Runnable)(k.attachment()); //调用之前注册的callback对象
        if (r != null)
            r.run();
    }
//Acceptor也是一个handler，负责创建socket并把新建的socket也注册到selector中    
    class Acceptor implements Runnable { // inner
        public void run() {
            try {
                SocketChannel c = serverSocket.accept();
                if (c != null)
                new Handler(selector, c);
            }
            catch(IOException ex) { /* ... */ }
        }
    }
}

//Concrete Handler：用于收发和处理消息。
//在当前的实现中，使用Runnable接口作为每个具体Handler的统一接口
//如果在处理时需要参数和返回值，也可以为Handler另外声明一个统一接口来代替Runnable接口
final class Handler implements Runnable {
    final SocketChannel socket;
    final SelectionKey sk;
    ByteBuffer input = ByteBuffer.allocate(MAXIN);
    ByteBuffer output = ByteBuffer.allocate(MAXOUT);
    static final int READING = 0, SENDING = 1;
    int state = READING;
     
    Handler(Selector sel, SocketChannel c) throws IOException {
        socket = c; c.configureBlocking(false);
        // Optionally try first read now
        sk = socket.register(sel, 0);
        sk.attach(this); //将Handler作为callback对象
        sk.interestOps(SelectionKey.OP_READ); //第二步,接收Read事件
        sel.wakeup();
    }
    boolean inputIsComplete() { /* ... */ }
    boolean outputIsComplete() { /* ... */ }
    void process() { /* ... */ }
     
    public void run() {
        try {
            if (state == READING) read();
            else if (state == SENDING) send();
        } catch (IOException ex) { /* ... */ }
    }
     
    void read() throws IOException {
        socket.read(input);
        if (inputIsComplete()) {
            process();
            state = SENDING;
            // Normally also do first write now
            sk.interestOps(SelectionKey.OP_WRITE); //第三步,接收write事件
        }
    }
    void send() throws IOException {
        socket.write(output);
        if (outputIsComplete()) sk.cancel(); //write完就结束了, 关闭select key
    }
}

//上面 的实现用Handler来同时处理Read和Write事件, 所以里面出现状态判断
//我们可以用State-Object pattern来更优雅的实现
class Handler { // ...
    public void run() { // initial state is reader
        socket.read(input);
        if (inputIsComplete()) {
            process();
            sk.attach(new Sender());  //状态迁移, Read后变成write, 用Sender作为新的callback对象
            sk.interest(SelectionKey.OP_WRITE);
            sk.selector().wakeup();
        }
    }
    class Sender implements Runnable {
        public void run(){ // ...
            socket.write(output);
            if (outputIsComplete()) sk.cancel();
        }
    }
}
```
- 多线程Reacotr
处理消息过程放在其他线程中执行
 ```java
class Handler implements Runnable {
    // uses util.concurrent thread pool
    static PooledExecutor pool = new PooledExecutor(...);
    static final int PROCESSING = 3;
    // ...
    synchronized void read() { // ...
        socket.read(input);
        if (inputIsComplete()) {
            state = PROCESSING;
            pool.execute(new Processer()); //使用线程pool异步执行
        }
    }
     
    synchronized void processAndHandOff() {
        process();
        state = SENDING; // or rebind attachment
        sk.interest(SelectionKey.OP_WRITE); //process完,开始等待write事件
    }
     
    class Processer implements Runnable {
        public void run() { processAndHandOff(); }
    }
}
```
- 使用多个selector
mainReactor只负责处理accept并创建socket，多个subReactor负责处理读写请求
 ```java
Selector[] selectors; //subReactors集合, 一个selector代表一个subReactor
int next = 0;
class Acceptor { // ...
    public synchronized void run() { ...
        Socket connection = serverSocket.accept(); //主selector负责accept
        if (connection != null)
            new Handler(selectors[next], connection); //选个subReactor去负责接收到的connection
        if (++next == selectors.length) next = 0;
    }
}
```
#AIO
AIO是真正的异步IO，它于JDK1.7时引入，它和NIO的区别在于：
- NIO仍然需要一个线程阻塞在select方法上，AIO则不需要
- NIO得到数据准备好的消息以后，仍然需要自己把消息复制到用户空间，AIO则是通过操作系统的支持把数据异步复制到用户空间以后再给应用进程发出信号。
 


James_ZhengTJ
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java网络编程】常用的网络模型
Sampson_S的博客
10-29 897
常用的网络模型 1.1 BIO 模型 网络编程的基本模型是 C/S 模型，即两个进程间的通信。服务端提供 IP 和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。传统的同步阻塞模型开发中，ServerSocket 负责绑定 IP 地址，启动监听端口；Socket 负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。 简单的描述一下 BIO 的服务端通信模型：采用 BIO 通信模型的服务端，通常由一个独立的 Acc
【JavaEE初阶系列】——网络初识—TCP/IP五层网络模型
最新发布
m0_74438843的博客
04-10 900
二进制数据来进行传递数据的。那天一个男生B见到天桥上一个女生在那站着，过去问请问你是不是来相亲的，那个女生说是的，然后我们就开始在桥边散步了，当我们边走边聊，男生B发现女生的情况和媒婆说的情况不一样，最后发现确实认错了，然后就和那个女生说抱歉，我们认错了，然后回到那个天桥之后，发现人已经走了。（应用层协议，往往是根据具体的场景，具体的需要，由程序员自主决定的）QQ应用程序，QQ就会把用户输入的“hello”，给打包成一个应用层的数据报（这个数据报的格式，得是qq的程序员才能知道的） 假设是按照下面的格式。
Java IO流详解（史上最全18个案例代码）
Liugx的博客
03-05 1650
Java IO流是Java中用于输入和输出数据的机制，它提供了一种灵活且强大的方式来处理文件、网络连接和其他数据源。IO流主要分为字节流和字符流两种类型，其中字节流适用于处理二进制数据，而字符流则适用于处理文本数据。Java IO流的核心是输入流和输出流，输入流用于从数据源读取数据，输出流用于向数据源写入数据。
计算IO设备、CPU利用率
weixin_48518371的博客
03-09 5908
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 计算IO设备、CPU利用率一、题目二、解题步骤0.分析：1.图解： 一、题目 在一个单CPU的处理机中，有P1，P3，P5三个作业，有两个IO设备IO1，IO2，并且能够实现抢先式多任务并行工作的多道程序环境中，投入运行优先级由高到低P5，P1，P3三个作业，他们使用设备的先后顺序和占用设备的时间分别为： P1:IO2(10ms) CPU(10ms) IO1(30ms）CPU(10ms)； P3:IO1(30ms) CPU(10ms)..
JAVA—IO流详解
weixin_48006490的博客
09-01 7960
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
BIO方式是Java中最早的网络IO实现方式。它的工作原理是：每个TCP连接到达服务端时，服务端都需要创建一个线程来建立连接并进行消息的处理。如果中间发生了阻塞（比如建立连接、读数据、写数据时发生阻碍），线程也...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而字符流用于处理文本数据。 Java中的...
java小项目练习IO实现
09-24
在这个“java小项目练习IO实现”中，我们将探讨如何利用Java的IO流来实现本地数据的序列化与反序列化，以及如何将这些概念应用到实际项目中，比如“Olymplic Games Project(IO版)”。 首先，让我们理解什么是序列化...
java-网络编程-io流-学习案例
02-25
通过这个案例，学习者可以深入理解Java网络编程的基本原理，掌握如何使用IO流进行数据交换，以及如何结合Swing创建功能丰富的图形界面。同时，这也是实践多线程编程的好机会，因为服务器需要同时处理多个客户端的...
网络编程+IO实现快递管理系统
01-20
综上，这个“网络编程+IO实现快递管理系统”项目，通过Java的网络编程技术实现了客户端与服务器的交互，利用IO操作处理本地文件系统中的快递信息，提供了一套完整的快递管理解决方案。开发者可能需要熟悉Socket编程...
如何获取网卡硬件地址
10-31
用ASP.NET如何获取网卡硬件地址的代码类实现
CSAPP 答案-Instructor's Manual of CSAPP
12-17
solutions to CSAPP homework
实现一个如图界面的计算器，要求点击若干按钮后，计算式能在首栏文本框中显示。
05-29
实现一个如图界面的计算器，要求点击若干按钮后，计算式能在首栏文本框中显示。
五种网络io模型
热门推荐
倦鸟归时
02-04 1万+
由于最近再看nginx，其采用了优于apache的select网络io模型，所以稍微了解了下网络io的模型的基础知识。 首先，介绍几种常见的I/O模型及其区别，如下： blocking I/O nonblocking I/O I/O multiplexing (select and poll) signal driven I/O (SIGIO)
java io流的分类_java中的IO流如何分类
weixin_42355215的博客
02-13 320
一、IO：上传下载，写入写出流: 一连串流动的数据，以先入先出的方式进行流动，管道，以程序为中心、程序与网络|文件|服务器|数组..(相关课程推荐：java视频教程)分类1)按照流向:输入流；输出流2)操作单元分:字节流 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频；字符流 :只能操作纯文本数据3)按照功能:节点流 : 包裹源头,实现基本功能；功能流 : 对节点流增强性能,提高效率...
java 网络编程的网络模型7层介绍：
qin的博客
12-01 1780
一：网络模型7层介绍：1.物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。 2. 数据链路层：主要将从物理层接收的数据进行MAC地址（网卡的地址）的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值