Java BIO NIO AIO

最新推荐文章于 2024-06-17 15:58:24 发布
最新推荐文章于 2024-06-17 15:58:24 发布
阅读量134 收藏
点赞数
分类专栏： Java技术 文章标签： NIO java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40910541/article/details/84334948
版权

文章目录

IO这一块需要学习BIO、NIO、AIO，上层可以了解TCP、UDP原理

NIO图解

AIO图解

NIO 服务端代码

提示

  1. 类NIOServer用于启动NIO服务器，传输参数只有PORT
  2. 类NIOServerHandle用于NIO服务器处理客户端的请求
NIOServer启动类
package com.ruider.customerNIO;

/**
 * Created by mahede on 2018/11/20.
 */
public class NIOServer {
    private static final int NIO_PORT = 1234;
    private static NIOServerHandle nioServerHandle;

    public static void start() { start(NIO_PORT); }

    private synchronized static void start(int port) {
        if(nioServerHandle != null) { nioServerHandle.stop(); }
        nioServerHandle = new NIOServerHandle(NIO_PORT);
        new Thread(nioServerHandle, "Server").start();
    }

}
NIO服务器处理请求类
package com.ruider.customerNIO;

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;
import java.util.Set;

/**
 * Created by mahede on 2018/11/20.
 */
public class NIOServerHandle implements Runnable{

    private int port;
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private volatile boolean start;

    public NIOServerHandle(int port) {
        this.port = port;
        try {
            selector = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().bind(new InetSocketAddress(port), 1024);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            start = true;
            System.out.println("NIOServer启动服务,端口：" + port);

        }catch (Exception e) {
            System.out.println("封装NIO服务失败");
            System.out.println(e);
        }
    }
    @Override
    public void run(){
        while(start) {
            try{
                //没1秒唤醒一次，轮询一遍事件
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                SelectionKey selectionKey = null;
                while(it.hasNext()) {
                    selectionKey = it.next();
                    it.remove();
                    try{
                        handleInput(selectionKey);
                    }catch(Exception e){
                        System.out.println("服务获取信息失败");
                        System.out.println(e);
                    }
                }
            }
            catch (Exception e) {
                System.out.println(e);
            }
        }
        if(selector != null)
            try{
                selector.close();
            }catch (Exception e) {
                e.printStackTrace();
            }

    }

    public void stop() { start = false;}

    private void handleInput(SelectionKey key) throws Exception{
        if(key.isValid()) {
            if(key.isAcceptable()) {
                ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                SocketChannel socketChannel = channel.accept();
                socketChannel.configureBlocking(false);
                socketChannel.register(selector, SelectionKey.OP_READ);

            }
            if(key.isReadable()) {
                SocketChannel socketChannel = (SocketChannel)key.channel();
                //分配1M的buffer
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                int size = socketChannel.read(byteBuffer);
                if(size > 0) {
                    //将缓冲区当前的limit设置为position=0，用于后续对缓冲区的读取操作
                    byteBuffer.flip();
                    byte[] bytes =  new byte[byteBuffer.remaining()];
                    //复制到bytes中
                    byteBuffer.get(bytes);
                    String contents = new String(bytes, "UTF-8");
                    System.out.println("NIO服务收到消息："+contents);

                    String expression = new String(bytes,"UTF-8");
                    System.out.println("服务器收到消息：" + expression);
                    doWrite(socketChannel, "收到信息，你好，我是NIO");
                }
                else if(size < 0) {
                    key.cancel();
                    socketChannel.close();
                }
            }
        }
    }

    private void doWrite(SocketChannel channel, String msg) {
        try {
            byte[] bytes = msg.getBytes();
            ByteBuffer writebuffer = ByteBuffer.allocate(bytes.length);
            writebuffer.put(bytes);
            //postion,limit值的交换，用于输出buffer
            writebuffer.flip();
            channel.write(writebuffer);
        }catch (Exception e) {
            System.out.print("[error]: NIOserver发送信息失败");
            e.printStackTrace();
        }
    }
}

NIO 客户端代码

提示

  1. 类Client用于启动NIO客户端，传输参数只有IP、PORT
  2. 类ClientHandle用于NIO客户端请求服务端以及处理服务端的数返回数据
NIO客户端启动类
package com.ruider.customerNIO;

/**
 * Created by mahede on 2018/11/21.
 */
public class Client {
    private static final String IP_ADDRESS = "localhost";
    private static final int PORT = 1234;
    private static ClientHandle clientHandle;

    public static void start(){ start(IP_ADDRESS, PORT);}

    private synchronized static void start(String host, int port) {
        if(clientHandle != null) {
            clientHandle.stop();
        }
        clientHandle = new ClientHandle(IP_ADDRESS, PORT);
        new Thread(clientHandle, "Client").start();
    }

    //向服务器发送消息
    public static boolean sendMsg(String msg) throws Exception{
        if(msg.equals("q")) return false;
        clientHandle.sendMsg(msg);
        return true;
    }

}
客户端发送请求和处理返回数据类
package com.ruider.customerNIO;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * Created by mahede on 2018/11/21.
 */
public class ClientHandle implements Runnable {

    private String ipAddress;
    private int port;
    private SocketChannel socketChannel;
    private Selector selector;
    private static boolean start;

    public ClientHandle(String host, int port) {
        try{
            this.ipAddress = host;
            this.port = port;
            selector = Selector.open();
            socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            //socketChannel.connect(new InetSocketAddress(ipAddress, port));
            //socketChannel.register(selector, SelectionKey.OP_CONNECT);
            start = true;
            System.out.println("客户端启动");
        }catch (Exception e) {
            System.out.println("客户端启动失败");
            e.printStackTrace();
        }

    }

    public static void stop() { start = false;}

    public void sendMsg(String msg) throws Exception{
        socketChannel.register(selector, SelectionKey.OP_READ);
        doWrite(socketChannel, msg);
    }

    @Override
    public void run() {
        try{
            doConnect();
        }catch (Exception e){
            e.printStackTrace();
            System.exit(1);
        }

        while (start) {
            try {
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                SelectionKey key = null;
                while (it.hasNext()) {
                    key = it.next();
                    it.remove();
                    try {
                        handleInput(key);
                    }
                    catch (Exception e) {
                        if(key != null){
                            key.cancel();
                            if(key.channel() != null){
                                key.channel().close();
                            }
                        }

                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
        try{
            if(selector != null) {
                selector.close();
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void handleInput(SelectionKey key) {
        if(key.isValid()) {
            try{
                SocketChannel socketChannel = (SocketChannel)key.channel();
                if(key.isConnectable()){
                    if(socketChannel.finishConnect());
                    else System.exit(1);
                }
                if(key.isReadable()){
                    //创建ByteBuffer，并开辟一个1M的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    //读取请求码流，返回读取到的字节数
                    int readBytes = socketChannel.read(buffer);
                    //读取到字节，对字节进行编解码
                    if(readBytes>0){
                        //将缓冲区当前的limit设置为position=0，用于后续对缓冲区的读取操作
                        buffer.flip();
                        //根据缓冲区可读字节数创建字节数组
                        byte[] bytes = new byte[buffer.remaining()];
                        //将缓冲区可读字节数组复制到新建的数组中
                        buffer.get(bytes);
                        String result = new String(bytes,"UTF-8");
                        System.out.println("客户端收到消息：" + result);
                    }
                    //没有读取到字节 忽略
//				else if(readBytes==0);
                    //链路已经关闭，释放资源
                    else if(readBytes<0){
                        key.cancel();
                        socketChannel.close();
                    }
                }
            }catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    //异步发送消息
    private void doWrite(SocketChannel channel,String request) throws IOException {
        //将消息编码为字节数组
        byte[] bytes = request.getBytes();
        //根据数组容量创建ByteBuffer
        ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
        //将字节数组复制到缓冲区
        writeBuffer.put(bytes);
        //flip操作
        writeBuffer.flip();
        //发送缓冲区的字节数组
        channel.write(writeBuffer);
        //****此处不含处理“写半包”的代码
    }

    private void doConnect() throws IOException{
        if(socketChannel.connect(new InetSocketAddress(ipAddress, port)));
        else socketChannel.register(selector, SelectionKey.OP_CONNECT);
    }
}
布玮
关注
专栏目录
java nio bio aio实例_Java的BIO，NIO，AIO
weixin_33899835的博客
02-25 238
1. 前言有一些概念总是Java I/O一块出现，比如同步与异步，阻塞与非阻塞，这些概念往往也是非常难以区分。在介绍Java I/O之前，本文先通俗地介绍一下这两组概念的区别：同步和异步: 同步和异步的区分点在消息的通知机制。如果是程序主动获取消息，为同步，程序被动获取消息，为异步。例如烧水，如果我们时不时去看看水是否烧开，则为同步。而如果水壶是会响笛的水壶，我们听见响笛则认为水烧开了，则为异步。...
java bio nio aio区别_如何理解BIO、NIO、AIO的区别？
weixin_39890452的博客
02-26 299
很多文章在谈论到BIO、NIO、AIO的时候仅仅是抛出一堆定义，以及一些生动的例子。看似很好理解。但是并没有将最基础的本质原理显现出来，如果没有没有从IO的原理出发的话是很难理解这三者之间的区别的。所以本篇文章从Java是如何进行IO操作为开头进行分析。Java中的IO原理首先Java中的IO都是依赖操作系统内核进行的，我们程序中的IO读写其实调用的是操作系统内核中的read&write两...
java bio nio aio区别_BIO、NIO、AIO有什么区别
weixin_39867296的博客
03-04 156
在学习Java I/O类库时，容易混淆NIO、BIO、AIO这几个概念，同时对于阻塞和非阻塞、同步和异步的理解也较为晦涩，这篇文章是对这几个概念的一些区分以及个人的一些见解。一、同步阻塞I/O(BIO)：同步阻塞I/O，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制来改善。BIO方式适用于连...
java bio nio aio详解_java 中的 BIO/NIO/AIO 详解
weixin_28998775的博客
03-04 223
java 的 IO 演进之路我们在前面学习了 linux 的 5 种 I/O 模型详解下面我们一起来学习下如何使用 java 实现 BIO/NIO/AIO 这 3 种不同的网络 IO 模型编程。BIO 编程BIO 作为最基础的 IO 版本，实现起来比较简单。Serverclient启动测试启动服务端启动客户端再次查看服务端日志线程池版本BIO 的缺点缺点其实非常明显，每次都要创建一个线程去处理。比...
java bio nio aio详解_BIO,NIO,AIO的理解(基础篇)
weixin_28792813的博客
03-06 175
此文参考：iteye在高性能的IO体系设计中，有几个名词概念常常会使我们感到迷惑不解。1.什么是同步？2.什么是异步？3.什么是阻塞？4.什么是非阻塞？5.什么是同步阻塞？6.什么是同步非阻塞？7.什么是异步阻塞？8.什么是异步非阻塞？1.同步，异步，阻塞，非阻塞 的定义对比图1.同步和异步是针对应用程序和内核的交互而言的。2.阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取...
java bio nio aio详解_「每日分享」网络编程-NIO、BIO、AIO详解
weixin_29620579的博客
02-28 214
引言java.nio全称java non-blocking IO，是指jdk1.4 及以上版本里提供的新api(New IO)，为所有的原始类型(boolean类型除外)提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。目录大纲1.阻塞和非阻塞2.同步和异步3.Java IO模型,NIO,BIO,AIO4.NIO的原理5.NIO操作流程6.代码演示1.阻塞和非阻塞阻塞和非阻塞是进程在访...
java nio bio aio_BIO NIO AIO区别
weixin_33286939的博客
02-21 316
介绍BIO 就是传统的 java.io 包，它是基于流模型实现的，交互的方式是同步、阻塞方式，也就是说在读入输入流或者输出流时，在读写动作完成之前，线程会一直阻塞在那里，它们之间的调用时可靠的线性顺序。它的有点就是代码比较简单、直观；缺点就是 IO 的效率和扩展性很低，容易成为应用性能瓶颈。NIO 是 Java 1.4 引入的 java.nio 包，提供了 Channel、Selector、Buf...
Java中BIO、NIO、AIO详解
最新发布
苏叶的专栏
06-17 922
参考： https://blog.csdn.net/s2152637/article/details/98777686 https://blog.csdn.net/bigorsmallorlarge/article/details/137292669注意：同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。 Java中的BIO分为两种：在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流
通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例
峡谷电光马仔的博客
10-28 2025
通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例 BIO 介绍与原理 场景描述 优点 缺点 ，BIO 代码示例 NIO 介绍与原理 场景描述 优点 缺点 ，NIO 代码示例 AIO 介绍与原理 场景描述 优点 缺点 ，AIO 代码示例
java BIO NIO AIO
07-18
Java BIO NIO AIO Java BIO、NIO、AIO是 Java 中的三种 I/O 模式，每种模式都有其特点和应用场景。下面对每种模式进行详细解释。 Java BIO Java BIO（ Blocking I/O）是一种同步阻塞式的 I/O 模式，即服务器实现...
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
Java作为一门广泛使用的开发语言，提供了多种I/O（Input/Output）通信模型，包括传统的阻塞I/O（BIO）、非阻塞I/O（NIO）以及异步I/O（AIO）。这些通信模型在不同的场景下有着各自的优势，理解和掌握它们对于优化...
bio nio aio demo
04-11
为了处理与外部世界的交互，Java提供了三种不同的I/O模型：BIO（ Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有优缺点，适用于不同场景。下面我们将深入探讨这三种I/O模型，并...
DataSource数据源简单理解
热门推荐
RuiDer的博客
06-22 7万+
DataSource数据源简单理解 因为热爱，所以拼搏。 –RuiDer 什么是数据源 JDBC2.0 提供了javax.sql.DataSource接口，它负责建立与数据库的连接，当在应用程序中访问数据库时 不必编写连接数据库的代码，直接引用DataSource获取数据库的连接对象即可。用于获取操作数据Connection对象。 数据源与数...
简单理解serialVersionUid的作用
RuiDer的博客
08-06 1万+
serialVersionUid的作用 多做少说，方能success。 –RuiDer 前导必备 Java序列化 IO 简单理解serialVersionUid的作用 serialVersionUid在序列化类中的代码示例： import java.io.Serializable; public class Test implements Serial...
JVM参数设置（吞吐量和响应时间性能调优）
RuiDer的博客
04-04 7495
吞吐量与响应时间 吞吐量 = CPU在用户应用程序运行的时间 / （CPU在用户应用程序运行的时间 + CPU垃圾回收的时间） FULL GC，串行垃圾回收会使用应用停顿，响应用户时间长 垃圾回收器算法比较 串行回收算法：会停止当前应用进程，回收垃圾，停顿时间久，吞吐量大，响应时间长 并行回收算法： 是多个线程同时执行串行回收算法（多核），也会使应用停顿，吞吐量大，响应时间长，用户体验差 并...
Mybatis N+1问题解析
RuiDer的博客
06-26 3330
Mybatis N+1问题解析 因为热爱，所以拼搏。 –RuiDer 前导必备 Mybatis 数据库 级联 N+1问题？？ N+1问题来源于数据库中常见的级联技术，即N个数据库表形成关联关系，当再增加一个关联表时，也就是N+1个级联关系，由于某些时候，我们并不需要加载数据库的所有数据，而是某一个数据库表中数据，这时Mybatis会自动加载所有表...
jvm内存模型，1.6 1.7 1.8哪里不同
RuiDer的博客
07-11 3232
JVM 因为热爱，所以拼搏。 –RuiDer XI. 前导必备 Java基础 JVM内存模型 XII. JVM内存模型 说明一下，也是我本人的亲身感受。如果你是入门JVM新手，之前接触过JVM方面的东西或者你个人存有自己对于JVM理解，我希望你暂时先屏蔽他们，不然会带来很大的干扰。 YI. Java内存区域划分 1.程序计数器（P...
JVM永久代
RuiDer的博客
09-17 3164
复习备用，感谢开源 永久代是用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响，但是有些应用可能动态生成或者调用一些class，例如Hibernate 等，在这种时候需要设置一个比较大的持久代空间来存放这些运行过程中新增的类，永久代中一般包含： 类的方法(字节码...) 类名(Sring对象) .class文件读到的常量信息 class对象相关的对象列表和类型列表 (e.g...
java nio bio aio
05-23
Java NIO、BIO 和 AIO 是 Java 中的三种不同的 I/O 编程模型。 BIO (Blocking IO) 是传统的 I/O 模型，它是同步阻塞的，也就是说，在进行 I/O 操作时，线程会一直阻塞直到数据准备好并返回。这种模型的缺点是效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值