一、BIO(Blocking IO,也被称作old IO)

同步阻塞模型,一个客户端连接对应一个处理线程

对于每一个新的网络连接都会分配给一个线程,每隔线程都独立处理自己负责的输入和输出, 也被称为Connection Per Thread模式

在这里插入图片描述

缺点:

1、IO代码里read操作是阻塞操作,如果连接不做数据读写操作会导致线程阻塞,浪费资源

2、如果线程很多,会导致服务器线程太多,压力太大,比如C10K问题

所谓c10k问题,指的是服务器同时支持成千上万个客户端的问题,也就是concurrent 10 000 connection

应用场景: BIO 方式适用于连接数目比较小且固定的架构, 这种方式对服务器资源要求比较高, 但程序简单易理解。

示例代码如下:

Bio服务端

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Title:BIO的服务端
 * @Author:wangchenggong
 * @Date 2021/4/13 9:41
 * @Description
 * @Version
 */
public class SocketServer {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true){
            System.out.println("等待连接...");
            Socket clientSocket = serverSocket.accept();
            System.out.println("客户端"+clientSocket.getRemoteSocketAddress()+"连接了!");

            handle(clientSocket);
        }

    }

    private static void handle(Socket clientSocket)  throws IOException{
        byte[] bytes = new byte[1024];
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read 客户端"+clientSocket.getRemoteSocketAddress()+"数据完毕");
        if(read != -1){
            System.out.println("接收到客户端的数据:" + new String(bytes, 0, read));
        }
        clientSocket.getOutputStream().write("HelloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }

}

Bio客户端

import java.io.IOException;
import java.net.Socket;

/**
 * @Title:BIO的客户端
 * @Author:wangchenggong
 * @Date 2021/4/13 9:49
 * @Description
 * @Version
 */
public class SocketClient {

    public static void main(String[] args) throws IOException {

        Socket socket = new Socket("localhost", 9000);
        //向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");

        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);

        System.out.println("接收到服务端的数据:" + new String(bytes));
        socket.close();
    }
}

二、NIO(Non Blocking IO,本意也作new IO)

同步非阻塞,服务器实现模式为 一个线程可以处理多个连接请求(连接),客户端发送的连接请求都会注册到多路复用器selector上,多路复用器轮询到连接有IO请求就进行处理,是在JDK1.4开始引入的。

应用场景:NIO方式适合连接数目多且连接比较短(轻操作)的架构,比如聊天服务器、弹幕系统、服务器之间通讯,编程相对复杂。

在这里插入图片描述

NIO 有三大核心组件: Channel(通道), Buffer(缓冲区),Selector(多路复用器)

1.channel类似于流,每个channel对应一个buffer缓冲区,buffer底层就是个数组

2.channel 会注册到selector上,由selector根据channel读写事件的发生将其交由某个空闲的线程处理

3.NIO的Buffer和Channel都是可读也可写的。

NIO的代码示例有两个

没有引入多路复用器的NIO

服务端

import java.io.IOException;
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.Iterator;
import java.util.List;

/**
 * @Title:Nio服务端
 * @Author:wangchenggong
 * @Date 2021/4/14 11:04
 * @Description
 * @Version
 */
public class NioServer {

    /**
     * 保存客户端连接
     */
    static List<SocketChannel> channelList = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        //创建Nio ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        //设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        System.out.println("Nio服务启动成功");

        while(true){
            //非阻塞模式accept方法不会阻塞
            /// NIO的非阻塞是由操作系统内部实现的,底层调用了linux内核的accept函数
            SocketChannel socketChannel = serverSocket.accept();
            if(socketChannel != null){
                System.out.println("连接成功");
                socketChannel.configureBlocking(false);
                channelList.add(socketChannel);
            }

            Iterator<SocketChannel> iterator = channelList.iterator();
            while(iterator.hasNext()){
                SocketChannel sc = iterator.next();
                ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                //非阻塞模式read方法不会阻塞
                int len = sc.read(byteBuffer);

                if(len > 0){
                    System.out.println("接收到消息:" + new String(byteBuffer.array()));
                }else if(len == -1){
                    iterator.remove();
                    System.out.println("客户端断开连接");
                }
            }

        }
    }
}

客户端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

/**
 * @Title:Nio客户端
 * @Author:wangchenggong
 * @Date 2021/4/14 11:36
 * @Description
 * @Version
 */
public class NioClient {

    public static void main(String[] args) throws IOException {

        SocketChannel socketChannel=SocketChannel.open(new InetSocketAddress("localhost", 9000));
        socketChannel.configureBlocking(false);


        ByteBuffer writeBuffer=ByteBuffer.wrap("HelloServer1".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服务端发送数据1结束");

        writeBuffer = ByteBuffer.wrap("HelloServer2".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服务端发送数据2结束");

        writeBuffer = ByteBuffer.wrap("HelloServer3".getBytes());
        socketChannel.write(writeBuffer);
        System.out.println("向服务端发送数据3结束");
    }


}

引入了多路复用器的NIO

服务端

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

/**
 * @Title:引入多路复用器后的NIO服务端
 * @Author:wangchenggong
 * @Date 2021/4/14 13:57
 * @Description
 * SelectionKey.OP_ACCEPT —— 接收连接继续事件,表示服务器监听到了客户连接,服务器可以接收这个连接了
 * SelectionKey.OP_CONNECT —— 连接就绪事件,表示客户与服务器的连接已经建立成功
 * SelectionKey.OP_READ —— 读就绪事件,表示通道中已经有了可读的数据,可以执行读操作了(通道目前有数据,可以进行读操作了)
 * SelectionKey.OP_WRITE —— 写就绪事件,表示已经可以向通道写数据了(通道目前可以用于写操作)
 *
 * 1.当向通道中注册SelectionKey.OP_READ事件后,如果客户端有向缓存中write数据,下次轮询时,则会 isReadable()=true;
 *
 * 2.当向通道中注册SelectionKey.OP_WRITE事件后,这时你会发现当前轮询线程中isWritable()一直为true,如果不设置为其他事件
 * @Version
 */
public class NioSelectorServer {

    public static void main(String[] args) throws IOException {

        /**
         * 创建server端,并且向多路复用器注册,让多路复用器监听连接事件
         */
        //创建ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        //设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        //打开selector处理channel,即创建epoll
        Selector selector = Selector.open();
        //把ServerSocketChannel注册到selector上,并且selector对客户端的accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("NioSelectorServer服务启动成功");


        while(true){
            //阻塞等待需要处理的事件发生
            selector.select();

            //获取selector中注册的全部事件的SelectionKey实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            //遍历selectionKeys,对事件进行处理
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                //如果是OP_ACCEPT事件,则进行连接和事件注册
                if(key.isAcceptable()){
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                    //接受客户端的连接
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    //把SocketChannel注册到selector上,并且selector对客户端的read操作(即读取来自客户端的消息)感兴趣
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端"+socketChannel.getRemoteAddress()+"连接成功!");

                }else if(key.isReadable()){
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    if(len > 0){
                        System.out.println("接收到客户端"+socketChannel.getRemoteAddress()+"发来的消息,消息内容为:"+new String(byteBuffer.array()));
                    }else if(len == -1){
                        System.out.println("客户端断开连接");
                        //关闭该客户端
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key,防止下次select重复处理
                iterator.remove();
            }

        }

        /**
         * NioSelectorServer服务启动成功
         * 客户端/127.0.0.1:57070连接成功!
         * 接收到客户端/127.0.0.1:57070发来的消息,消息内容为:HelloServer
         * 客户端/127.0.0.1:57121连接成功!
         * 接收到客户端/127.0.0.1:57121发来的消息,消息内容为:HelloServer
         */

    }
}

客户端

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;

/**
 * @Title:引入多路复用器后的NIO客户端
 * @Author:wangchenggong
 * @Date 2021/4/14 14:39
 * @Description
 * @Version
 */
public class NioSelectorClient {

    public static void main(String[] args) throws IOException {

        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        //要先向多路复用器注册,然后才可以跟服务端进行连接
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
        socketChannel.connect(new InetSocketAddress("localhost", 9000));

        while (true){
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = keys.iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                if (key.isConnectable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    if (sc.finishConnect()){
                        System.out.println("服务器连接成功");

                        ByteBuffer writeBuffer=ByteBuffer.wrap("HelloServer".getBytes());
                        sc.write(writeBuffer);
                        System.out.println("向服务端发送数据结束");
                    }
                }
            }
        }

        /**
         * 服务器连接成功
         * 向服务端发送数据结束
         */

    }
}

三、AIO(Asynchronous IO) 即NIO2.0

异步非阻塞,由操作系统完成后回调通知服务端程序启动线程去处理,一般适用于连接数较多且连接时间较长的应用。

应用场景:AIO方式适用于连接数目多且连接时间较长(重操作)的架构(应用),JDK7开始支持。

著名的异步网络通讯框架netty之所以废弃了AIO,原因是:在Linux系统上,NIO的底层实现使用了Epoll,而AIO的底层实现仍使用Epoll,没有很好实现AIO,因此在性能上没有明显的优势,而且被JDK封装了一层不容易深度优 化,Linux上AIO还不够成熟

AIO示例代码如下:

服务端

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

/**
 * @Title:Aio服务端
 * @Author:wangchenggong
 * @Date 2021/4/14 17:05
 * @Description
 * @Version
 */
public class AioServer {

    public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                try{
                    System.out.println("2--"+Thread.currentThread().getName());
                    //接收客户端连接
                    serverChannel.accept(attachment,this);
                    System.out.println("客户端"+socketChannel.getRemoteAddress()+"已连接");

                    ByteBuffer buffer = ByteBuffer.allocate(128);
                    socketChannel.read(buffer, null, new CompletionHandler<Integer, Object>() {
                        @Override
                        public void completed(Integer result, Object attachment) {
                            System.out.println("3--"+Thread.currentThread().getName());
                            //flip方法将Buffer从写模式切换到读模式
                            //如果没有,就是从文件最后开始读取的,当然读出来的都是byte=0时候的字符。通过buffer.flip();这个语句,就能把buffer的当前位置更改为buffer缓冲区的第一个位置
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("hello Aio Client!".getBytes()));
                        }

                        @Override
                        public void failed(Throwable exc, Object attachment) {
                            exc.printStackTrace();
                        }
                    });

                }catch(Exception e){
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {

            }
        });

        System.out.println("1‐‐main"+Thread.currentThread().getName());
        Thread.sleep(Integer.MAX_VALUE);
    }
    /**
     * 1‐‐mainmain
     * 2--Thread-9
     * 客户端/127.0.0.1:54821已连接
     * 3--Thread-8
     * hello AIO server !
     * 2--Thread-9
     * 客户端/127.0.0.1:54942已连接
     * 3--Thread-7
     * hello AIO server !
     */

}

客户端

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;

/**
 * @Title:Aio客户端
 * @Author:wangchenggong
 * @Date 2021/4/14 16:56
 * @Description
 * @Version
 */
public class AioClient {

    public static void main(String[] args) throws Exception {

        //创建Aio客户端
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("localhost", 9000)).get();
        //发送消息
        socketChannel.write(ByteBuffer.wrap("hello AIO server !".getBytes()));
        //接收消息
        ByteBuffer buffer = ByteBuffer.allocate(128);
        Integer len = socketChannel.read(buffer).get();
        if(len != -1){
            //客户端收到消息:hello Aio Client!
            System.out.println("客户端收到消息:"+new String(buffer.array(), 0, len));
        }
    }


}

四、总结

BIO NIO AIO
IO模型 同步阻塞 同步非阻塞 异步非阻塞
编程难度 简单 复杂 复杂
可靠性 好
吞吐量

到此这篇关于java中BIO、NIO、AIO都有啥区别的文章就介绍到这了,更多相关java中BIO、NIO、AIO的区别内容请搜索程序员的世界以前的文章或继续浏览下面的相关文章希望大家以后多多支持程序员的世界!

java中BIO、NIO、AIO都有啥区别的更多相关文章

  1. java实现表格数据的存储

    本文实例为大家分享了java实现表格数据存储的具体代码,供大家参考,具体内容如下一、二维数组实现表格数据的存储import java.util.Arrays;/*** 使用Object[][]存储表格信息* @author Lhk**/public class Array_Test01 {publi......

  2. java利用socket通信实现Modbus-RTU通信协议的示例代码

    ModbusModbus是一种串行通信协议。Modbus 一个工业上常用的通讯协议、一种通讯约定。Modbus协议包括RTU、ASCII、TCP。其中MODBUS-RTU最常用,比较简单,在单片机上很容易实现。简单分析Modbus-RTU报文37 03 10 3F 80 00 00 00 00 00......

  3. Java 使用拦截器无限转发/重定向无限循环/重定向次数过多报错(StackOverflowError) 解决方案

    说明:当使用拦截器出现“请求转发”无限循环或者“重定向”次数过多这种问题的时候,一般都是 拦截器 设置错了情况一:请求转发时没有配置排除拦截路径,就是说你访问的路径都拦截了,导致一直转发,从而产生java.lang.StackOverflowError错误情况二:重定向时没有配置排除拦截路径,会导致......

  4. java HttpClient传输json格式的参数实例讲解

    最近的一个接口项目,传的参数要求是json,需要特殊处理一下。重点是这两句话:httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");se.setContentType(CONT......

  5. java编译命令基础知识点

    我们在对计算机下达指令时,人类的语言它是不能够明白,需要通过编译的时候翻译成计算机能听懂的语言。编译过程中会调用javac命令,这点大家可能接触的不多,毕竟是是计算机程序内部运行时的操作。下面我们就编译的概念、命令带来讲解,然后分享一个编译实例给大家练习。1.编译概念通过流程图可以看出其实java的......

  6. java中Supplier知识点总结

    1、说明这个接口是提供者的意思,只有一个抽象的get,没有默认的方法和静态的方法,导入一个泛T,get方法,返回一个泛T。supplier也用于创建对象,但与传统的创建对象语法不同:new,Supplier不同于Function,它不接受参数,直接为我们生产指定的结果,有点像生产者模式。2、实例cl......

  7. 如何讲清楚 Java 面向对象的问题与知识?(类与对象,封装,继承,多态,接口,内部类...)

    如何讲清楚 Java 面向对象的问题与知识?(类与对象,封装,继承,多态,接口,内部类...)写在最前面这个项目是从20年末就立好的 flag,经过几年的学习,回过头再去看很多知识点又有新的理解。所以趁着找实习的准备,结合以前的学习储备,创建一个主要针对应届生和初学者的 Java 开源知识项目,专注......

  8. Java编程技术之浅析SPI服务发现机制

    SPI服务发现机制SPI是Java JDK内部提供的一种服务发现机制。SPI->Service Provider Interface,服务提供接口,是Java JDK内置的一种服务发现机制通过在ClassPath路径下的META-INF/services文件夹查找文件,自动加载文件里所定义的类......

  9. Java多线程总结(一)

    多线程作为Java中很重要的一个知识点,在此还是有必要总结一下的。一.线程的生命周期及五种基本状态关于Java中线程的生命周期,首先看一下下面这张较为经典的图:上图中基本上囊括了Java中多线程各重要知识点。掌握了上图中的各知识点,Java中的多线程也就基本上掌握了。主要包括:Java线程具有五中基......

  10. Java 容器系列总结

    为什么要使用集合当我们需要保存一组类型相同的数据的时候,我们应该是用一个容器来保存,这个容器就是数组,但是,使用数组存储对象具有一定的弊端, 因为我们在实际开发中,存储的数据的类型是多种多样的,于是,就出现了“集合”,集合同样也是用来存储多个数据的。数组的缺点是一旦声明之后,长度就不可变了;同时,声......

随机推荐

  1. ASP删除img标签的style属性只保留src的正则函数

    ASP去除img标签style属性只保留src'功能:将IMG代码格式化为<img src="XXX" />格式,只保留SRC属性,去掉IMG标签的其他属性。Function FixImg(sString) Dim sReallyDo......

  2. 如何在C#中使用只读的 Collections

    集合 表示一组可用于获取和存储的对象,在 C# 中提供了两种类型的集合。普通集合泛型集合前者存在于 System.Collections 命名空间下,属类型不安全的,后者存在于 System.Collections.Generic 命名空间下,属类型安全的。不可变对象 定义为一旦创建就不可变更的对象......

  3. 详解Android的四大应用程序组件

    Android的一个核心特性就是一个应用程序可作为其他应用程序中的元素,可为其他应用程序提供数据。例如,如果程序需要用某些控件来加载一些图片,另一个程序已经开发出了此项功能,且可供其他程序使用,就可以直接使用跨进程通信方式调用那个程序的功能,而不是自己再开发一个。为了实现这样的功能,Android系......

  4. 使用Groovy构建DSL

    DSL(Domain Specific Language)是针对某一领域,具有受限表达性的一种计算机程序设计语言。常用于聚焦指定的领域或问题,这就要求 DSL 具备强大的表现力,同时在使用起来要简单。由于其使用简单的特性,DSL 通常不会像 Java,C++等语言将其应用于一般性的编程任务。对于 G......

  5. 用PHP实现的服务端socket具体实例

    实现方法如下:使用到的相关函数: socket_create、socket_set_block、socket_bind、socket_listen、socket_accept、socket_read、socket_write,这些函数具体参数说明在PHP文档上写很详细,这里就不再赘述,这里只是介绍服......

  6. 详解java中static关键词的作用

    在java中,static是一个修饰符,用于修饰类的成员方法、类的成员变量,另外可以编写static代码块来优化程序性能;被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。static关键词的作用1、静态成员变量的语法特定2、静态函数的语法特......

  7. Android自定义view仿QQ的Tab按钮动画效果(示例代码)

    话不多说 先上效果图实现其实很简单,先用两张图一张是背景的图,一张是笑脸的图片,笑脸的图片是白色,可能看不出来。实现思路:主要是再触摸view的时候同时移动这两个图片,但是移动的距离不一样,造成的错位感,代码很简单:import android.content.Contextimport andro......

  8. Python解析JSON对象

    前言本章节我们将为大家介绍如何使用 Python 语言来编码和解码 JSON 对象。json处理模块的主要任务,是将一个JSON对象,转换成Python数据类型数据进行处理,或者反之,将Python数据类型数据,转换成JSON对象(字符串流),在不同的模块或者系统间传输。1. JSON数据格式特点对......

  9. JavaScript中的Proxy对象

    Js中Proxy对象Proxy对象用于定义基本操作的自定义行为,例如属性查找、赋值、枚举、函数调用等。语法const proxy = new Proxy(target, handler);target: 要使用Proxy包装的目标对象,可以是任何类型的对象,包括原生数组,函数,甚至另一个代理。han......

  10. linux 查看文件系统类型实例方法

    在Linux 中如何查看分区的文件系统类型,下面总结几种查看分区文件系统类型的方法。1: df -T 命令查看这个是最简单的命令,文件系统类型在Type列输出。只可以查看已经挂载的分区和文件系统类型。如下所示:[root@mylnx008 ~]# df -T /dev/sdbFilesystem ......