Java BOI与NIO超详细实例精讲

目录
  • Java BIO
    • 示例代码
  • Java NIO
    • 代码解读

Java BIO

阻塞IO,每个客户端链接都需要一个独立的线程处理,客户端链接没关闭时,线程链接处于阻塞状态,直到客户端链接关闭

如果客户端链接没有读取到数据,链接就会一直阻塞住,造成资源浪费

示例代码

开发一个ServerSocket服务端,通过telnet链接发送信息

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class BIOServerTest {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newCachedThreadPool();
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端启动");
        while (true) {
            System.out.println("等待链接...");
            Socket socket = serverSocket.accept();
            pool.execute(() -> {
                handler(socket);
            });
        }
    }
    private static void handler(Socket socket) {
        try {
            System.out.println("有一个客户端接入:" + Thread.currentThread().getName());
            byte[] bytes = new byte[1024];
            //通过socket 获取输入流
            InputStream inputStream = socket.getInputStream();
            //循环读取客户端发送的数据
            while (true) {
                System.out.println("等待读取数据...");
                int read = inputStream.read(bytes);
                if (read != -1) {
                    //输出客户端读取的数据
                    System.out.println("线程信息:" + Thread.currentThread().getName());
                    System.out.println(new String(bytes, 0, read));
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("关闭client链接:" + Thread.currentThread().getName());
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

通过telnet链接两个客户端,分别发送请求

从控制台打印信息可以看出每一个链接对应的线程都是独立的

等待链接...
有一个客户端接入:pool-1-thread-1
等待读取数据...
线程信息:pool-1-thread-1
aaa
等待读取数据...
线程信息:pool-1-thread-1
bbb
等待读取数据...
等待链接...
有一个客户端接入:pool-1-thread-2
等待读取数据...
线程信息:pool-1-thread-2
ccc
等待读取数据...
线程信息:pool-1-thread-2
ddd
等待读取数据...

Java NIO

非阻塞IO,通过Selector和Channel,实现一个线程维护多个链接

NIO有三大核心部分:Channel(通道),Buffer(缓冲区),Selector(选择器)

NOI是面向缓冲区编程的,数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,增加的处理过程的灵活性,使用它可以提供非阻塞式的高伸缩性网络

NIO是通过事件驱动编程的,Selector会根据不同的事件,在各个通道上切换

Channel同时支持读写双向处理

Selector能够监测到多个注册的通到是否有事件发生,这样就可以只用一个线程去管理多个通道,也就是管理多个链接和请求。

只有在链接真正有读写事件发生时,才会进行读写,大大减少了系统开销,并且不必为每个链接创建一个线程

代码解读

  • 当客户端链接时,会通过ServerSocketChannel得到SocketChannel
  • 将SocketChannel注册到Selector上,一个selector上可以注册多个SocketChannel
  • 通过socketChannel.register()方法注册
  • 注册后返回一个SelectionKey,会和该Selector关联
  • Selector监听select方法,返回有事件发生的通道的个数
  • 进一步得到有事件发生的各个SelectionKey,通过SelectionKey反向获取SocketChannel
  • 通过得到的channel完成业务处理

1)服务端代码

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;
public class NIOServer {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);
        serverSocketChannel.socket().bind(inetSocketAddress);
        serverSocketChannel.configureBlocking(false);
        Selector selector = Selector.open();
        //注册客户端链接事件到selector
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            int select = selector.select(1000L);
            if (select == 0) {
                System.out.println("等待1秒,没有事件发生");
                continue;
            }
            //监听到相关事件发生,读取SelectionKey集合,遍历处理所有事件
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                if (key.isAcceptable()) {
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.println("客户端链接成功,生成一个sockeChannel " + socketChannel.hashCode());
                    //将socketChannel设置为非阻塞
                    socketChannel.configureBlocking(false);
                    //注册内容读取事件到selector,同时关联一个Buffer
                    socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if (key.isReadable()) {
                    SocketChannel channel = null;
                    try {
                        channel = (SocketChannel) key.channel();
                        ByteBuffer byteBuffer = (ByteBuffer) key.attachment();
                        int read = channel.read(byteBuffer);
                        System.out.println("读取到数据: " + new String(byteBuffer.array(), 0, read));
                    } catch (Exception e) {
                        if (channel != null) {
                            channel.close();
                        }
                        e.printStackTrace();
                    }
                }
                //手动从集合中移除当前的SelectionKey,防止重复操作
                keyIterator.remove();
            }
        }
    }
}

2)客户端代码

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class NIOClient {
    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 7000);
        if (!socketChannel.connect(inetSocketAddress)){
            while (!socketChannel.finishConnect()){
                System.out.println("链接未完成,客户端不会阻塞....");
            }
        }
        String str = "Hello,你好~~~";
        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
        socketChannel.write(byteBuffer);
        System.in.read();
    }
}

控制台输出

等待1秒,没有事件发生
等待1秒,没有事件发生
等待1秒,没有事件发生
等待1秒,没有事件发生
等待1秒,没有事件发生
客户端链接成功,生成一个sockeChannel 60559178
读取到数据: Hello,你好~~~
等待1秒,没有事件发生

到此这篇关于Java BOI与NIO超详细实例精讲的文章就介绍到这了,更多相关Java BOI与NIO内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • JavaIO模型中的BIO,NIO和AIO详解

    目录 一.I/O模型 1.1 I/O模型基本说明 1.2 Java支持的3种网络编程I/O模式 1.3 JavaBIO(同步阻塞) 1.4 JavaNIO (同步非阻塞) 1.5 JavaAIO(异步非阻塞) 二.BIO.NIO.AIO适用场景分析 2.1 BIO应用场景 2.2 NIO应用场景 2.3 AIO应用场景 总结 一.I/O模型 1.1 I/O模型基本说明 I/O模型的简单理解:I/O模型就是用什么样的通道进行数据的发送和接受,很大程度上决定了程序通信的性能 1.2 Java支持的3

  • Java NIO Channel 使用详情

    目录 FileChannel 输入 FileInputStream 输出 FileOutputStream RandomAccessFile 两个 SocketChannel ServerSocketChannel SocketChannel Datagram Java NIO 中的 Channel 分类: FileChannel SocketChannel ServerSocketChannel DatagramChannel FileChannel: 主要用于文件的读写,可以从磁盘上读取文件

  • Java NIO 中 Selector 解析

    目录 一.Selector 简介 1.Selector 和 Channel 关系 2.可选择通道(SelectableChannel) 3.Channel 注册到 Selector 4.选择键(SelectionKey) 二.Selector 的使用方法 1.Selector 的创建 2.注册 Channel 到 Selector 3.轮训查询就绪操作 4.停止选择的方法 三.示例代码 1.服务端代码 2.客户端代码 3.NIO 编程步骤总结 一.Selector 简介 1.Selector 和

  • Java NIO 中Buffer 缓冲区解析

    目录 一.Buffer 简介 二.Buffer 的基本方法 1.使用 Buffer 读写数据 2.使用 Buffer 的例子 三.Buffer 的 capactity.posittion 和limit 四.Buffer 的类型 五.Buffer 分配和写数据 1. Buffer 分配 2.向 buffer 中写数据 3.flip() 方法 六.从 Buffer 中读取数据 七.Buffer 几个方法 1.rewind() 方法 2.clear() 与 compact() 方法 3.mark()

  • Java图文并茂详解NIO与零拷贝

    目录 一.概念说明 1.传统IO 2.mmap 3.sendfile 4.mmap与sendfile 二.传统IO传输文件代码示例 1.服务端代码 2.客户端代码 3.控制台出输出 三.NIO传输文件代码示例 1.服务端代码 2.客户端代码 3.控制台出输出 四.总结 零拷贝指的是没有CPU拷贝,并不是不拷贝:减少上下文切换 一.概念说明 1.传统IO 需要4次拷贝,3次上下文切换 2.mmap mmap 通过内存映射,将文件映射到内存缓冲区,同时用户空间可以共享内存缓冲区的数据,减少内核空间到

  • Java使用NIO优化IO实现文件上传下载功能

    目录 1 NIO的一些基础预备知识 2 NIO为何较传统的io速度较快 3 NIO实战上传下载 3.1 url下载文件 3.2 通过NIO上传文件 1 NIO的一些基础预备知识 Java中IO流类的体系中BIO与NIO:https://blog.csdn.net/ZGL_cyy/article/details/104326458Java IO体系与NIO和BIO体系面试题 :https://blog.csdn.net/ZGL_cyy/article/details/122836368为什么使用N

  • Java NIO与IO的区别以及比较

    目录 前言 一.NIO的简介 二.IO的传统方式 三.NIO的详细介绍 四. 举例说明 前言 传统的socket IO中,需要为每个连接创建一个线程,当并发的连接数量非常巨大时,线程所占用的栈内存和CPU线程切换的开销将非常巨大.使用NIO,不再需要为每个线程创建单独的线程,可以用一个含有限数量线程的线程池,甚至一个线程来为任意数量的连接服务.由于线程数量小于连接数量,所以每个线程进行IO操作时就不能阻塞,如果阻塞的话,有些连接就得不到处理,NIO提供了这种非阻塞的能力. 小量的线程如何同时为大

  • Java中BIO、NIO和AIO的区别、原理与用法

    目录 IO BIO NIO AIO 区别及联系 各自适用场景 使用方式 IO 什么是IO? 它是指计算机与外部世界或者一个程序与计算机的其余部分的之间的接口.它对于任何计算机系统都非常关键,因而所有 I/O 的主体实际上是内置在操作系统中的.单独的程序一般是让系统为它们完成大部分的工作. 在 Java 编程中,直到最近一直使用 流 的方式完成 I/O.所有 I/O 都被视为单个的字节的移动,通过一个称为 Stream 的对象一次移动一个字节.流 I/O 用于与外部世界接触.它也在内部使用,用于将

  • Java BOI与NIO超详细实例精讲

    目录 Java BIO 示例代码 Java NIO 代码解读 Java BIO 阻塞IO,每个客户端链接都需要一个独立的线程处理,客户端链接没关闭时,线程链接处于阻塞状态,直到客户端链接关闭 如果客户端链接没有读取到数据,链接就会一直阻塞住,造成资源浪费 示例代码 开发一个ServerSocket服务端,通过telnet链接发送信息 import java.io.IOException; import java.io.InputStream; import java.net.ServerSock

  • Java 对象序列化 NIO NIO2详细介绍及解析

    Java 对象序列化 NIO NIO2详细介绍及解析 概要: 对象序列化 对象序列化机制允许把内存中的Java对象转换成与平台无关的二进制流,从而可以保存到磁盘或者进行网络传输,其它程序获得这个二进制流后可以将其恢复成原来的Java对象. 序列化机制可以使对象可以脱离程序的运行而对立存在 序列化的含义和意义 序列化 序列化机制可以使对象可以脱离程序的运行而对立存在 序列化(Serialize)指将一个java对象写入IO流中,与此对应的是,对象的反序列化(Deserialize)则指从IO流中恢

  • Java 继承与多态超详细梳理

    目录 一.继承 1.继承的概念 2.继承的语法 3.父类成员访问 (1)子类中访问父类的成员变量 (2)子类中访问父类的成员方法 4.super关键字 5.子类构造方法 6.super和this 7.代码块执行顺序 8.继承方式 9.final关键字 10.继承和组合 二.多态 1.向上转型 2.重写 3.多态 一.继承 1.继承的概念 继承机制:是面向对象程序设计是代码可以复用的最重要手段,允许程序员在保持原有类特性的基础上进行扩展,增加新的功能,产生的新类,成为派生类/子类.继承主要解决的问

  • Netty与NIO超详细讲解

    目录 Linux下的五种I/O模型 阻塞IO的流程 IO复用 信号驱动I/O 异步IO NIO I0多路复用 NIO核心组件 使用Java原生API实现NIO操作 Redis为什么支持高并发 Linux下的五种I/O模型 1)阻塞I/O(blocking I/O) 2)非阻塞I/O (nonblocking I/O) 3) I/O复用(select 和poll) (I/O multiplexing) 4)信号驱动I/O (signal driven I/O (SIGIO)) 5)异步I/O (a

  • Java TCP协议通信超详细讲解

    目录 什么是tcp 服务端 客户端 服务端与客户端代码实现实例 什么是tcp Tcp通信有两个特点分别是面向连接,具有可靠性. 面向连接:指的是客户端与服务端之间的连接,在通信之前会有三次握手的机制来确保连接的可靠性. 可靠性:tcp在确保他的可靠性上做了许多的功夫,这个可靠性体现在下面两方面: tcp有状态:tcp会精确的纪录哪些数据是发送了的,哪些是没有被发送的,他保证数据包是按序到达的,不允许存在半点差错 tcp是可以控制的:如果存在丢包或者网络不好的时候,会根据具体情况对数据包进行发送速

  • Java 栈与队列超详细分析讲解

    目录 一.栈(Stack) 1.什么是栈? 2.栈的常见方法 3.自己实现一个栈(底层用一个数组实现) 二.队列(Queue) 1.什么是队列? 2.队列的常见方法 3.队列的实现(单链表实现) 4.循环队列 一.栈(Stack) 1.什么是栈? 栈其实就是一种数据结构 - 先进后出(先入栈的数据后出来,最先入栈的数据会被压入栈底) 什么是java虚拟机栈? java虚拟机栈只是JVM当中的一块内存,该内存一般用来存放 例如:局部变量当调用函数时,我们会为函数开辟一块内存,叫做 栈帧,在 jav

  • Java SpringMVC数据响应超详细讲解

    目录 1)页面跳转   2)回写数据 3)配置注解驱动 4)知识要点 1)页面跳转   直接返回字符串:此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转.  返回带有前缀的字符串: 转发: forward:/WEB-INF/views/index.jsp 重定向: redirect:/index.jsp 通过ModelAndView对象返回 @RequestMapping("/quick2") public ModelAndView quickMethod2(){ ModelAn

  • Java CopyOnWriteArrayList源码超详细分析

    目录 一.概述 二.类图 三.核心方法 1.add() 2.set() 3.remove() 4.get() 5.size() 四.总结 一.概述 CopyOnWriteArrayList是基于写时复制技术实现的,适用于读多写少场景下的线程安全的并发容器.读操作永远不会加锁,读读.读写都不会冲突,只有写写需要等待.写操作时,为了不影响其它线程的读取,它会进行一次自我复制,待数据写入完成后再替换array数组.array数组是被volatile修饰的,它被修改后可以被其他线程立刻发现. publi

  • Java依赖注入容器超详细全面讲解

    目录 一.依赖注入Dependency Injection 二.解析 2.1 典型的配置文件 2.2 配置文件所对应的Java类 2.3 定义解析器 三.bean工厂(根据bean定义创建bean对象) 四.DI容器(上下文) 4.1 容器接口 4.2 XML容器 五.使用DI容器 一.依赖注入Dependency Injection DI容器底层最基本的设计思路就是基于工厂模式. DI容器的核心功能:配置解析.对象创建.对象声明周期. 完整的代码:Dependency Injection. 二

  • MySQL实例精讲单行函数以及字符数学日期流程控制

    目录 一.字符函数 1.大小写控制函数 2.字符控制函数 二.数学函数 三.日期函数 四.其他函数 五.流程控制函数 一.字符函数 1.大小写控制函数 ①UPPER():转换成大写 SELECT UPPER('Hello'); ②LOWER():转换成小写 SELECT LOWER('Hello'); 2.字符控制函数 ①LENGTH():获取参数值的字节个数 SELECT LENGTH('叶绿体不忘呼吸aaaa'); ②CONCAT():拼接字符串 SELECT CONCAT('Hello',

随机推荐