NIO学习笔记

最新推荐文章于 2023-04-04 09:28:21 发布
最新推荐文章于 2023-04-04 09:28:21 发布
阅读量83 收藏
点赞数
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32806781/article/details/104190348
版权

1、NIO三大核心 buteBuffer、channel、Selector
2、ByteBuffer 使用

public static void main(String[] args) {
        // 构建一个byte字节缓冲区，容量是4
        ByteBuffer byteBuffer = ByteBuffer.allocate(4);
        // 默认写入模式，查看三个重要的指标
        System.out.println(String.format("初始化：capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));
        // 写入2字节的数据
        byteBuffer.put((byte) 1);
        byteBuffer.put((byte) 2);
        byteBuffer.put((byte) 3);
        // 再看数据
        System.out.println(String.format("写入3字节后，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));

        // 转换为读取模式(不调用flip方法，也是可以读取数据的，但是position记录读取的位置不对)
        System.out.println("#######开始读取");
        byteBuffer.flip();
        byte a = byteBuffer.get();
        System.out.println(a);
        byte b = byteBuffer.get();
        System.out.println(b);
        System.out.println(String.format("读取2字节数据后，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));

        // 继续写入3字节，此时读模式下，limit=3，position=2.继续写入只能覆盖写入一条数据
        // clear()方法清除整个缓冲区。compact()方法仅清除已阅读的数据。转为写入模式
        byteBuffer.compact(); // buffer : 1 , 3
        byteBuffer.put((byte) 3);
        byteBuffer.put((byte) 4);
        byteBuffer.put((byte) 5);
        System.out.println(String.format("最终的情况，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));
         // rewind() 重置position为0
        // mark() 标记position的位置
        // reset() 重置position为上次mark()标记的位置

可是使用allocateDirect申请ByteBuffer为堆外内存
注意：
1、堆外内存使用要控制大小，
2、读取数据是要调用byteBuffer.flip();将ByteBuffer转换为读模式，原理：是将positon归0
3、NIO代码实例

public class NIOServerV2 {

    public static void main(String[] args) throws Exception {
        // 1. 创建网络服务端ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式

        // 2. 构建一个Selector选择器,并且将channel注册上去
        Selector selector = Selector.open();
        SelectionKey selectionKey = serverSocketChannel.register(selector, 0, serverSocketChannel);// 将serverSocketChannel注册到selector
        selectionKey.interestOps(SelectionKey.OP_ACCEPT); // 对serverSocketChannel上面的accept事件感兴趣(serverSocketChannel只能支持accept操作)

        // 3. 绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));

        System.out.println("启动成功");

        while (true) {
            // 不再轮询通道,改用下面轮询事件的方式.select方法有阻塞效果,直到有事件通知才会有返回
            selector.select();
            // 获取事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 遍历查询结果e
            Iterator<SelectionKey> iter = selectionKeys.iterator();
            while (iter.hasNext()) {
                // 被封装的查询结果
                SelectionKey key = iter.next();
                iter.remove();
                // 关注 Read 和 Accept两个事件
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.attachment();
                    // 将拿到的客户端连接通道,注册到selector上面
                    SocketChannel clientSocketChannel = server.accept(); // mainReactor 轮询accept
                    clientSocketChannel.configureBlocking(false);
                    clientSocketChannel.register(selector, SelectionKey.OP_READ, clientSocketChannel);
                    System.out.println("收到新连接 : " + clientSocketChannel.getRemoteAddress());
                }

                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.attachment();
                    try {
                        ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                        while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
                            // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                            if (requestBuffer.position() > 0) break;
                        }
                        if(requestBuffer.position() == 0) continue; // 如果没数据了, 则不继续后面的处理
                        requestBuffer.flip();
                        byte[] content = new byte[requestBuffer.limit()];
                        requestBuffer.get(content);
                        System.out.println(new String(content));
                        System.out.println("收到数据,来自：" + socketChannel.getRemoteAddress());
                        // TODO 业务操作 数据库 接口调用等等

                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                        while (buffer.hasRemaining()) {
                            socketChannel.write(buffer);
                        }
                    } catch (IOException e) {
                        // e.printStackTrace();
                        key.cancel(); // 取消事件订阅
                    }
                }
            }
            selector.selectNow();
        }
      
    }
}

问题： 此处一个selector监听所有事件,一个线程处理所有请求事件. 会成为瓶颈! 要有多线程的运用
4、Reactor解决方案
分为三个类 ReactorThread封装Selector的操作，Reactormain为Reactor的实现，App为测试类
ReactorThread
原理：将NIO操作分为三个线程集合（Reactormain）workPool、mainReactorThreads、subReactorThreads
workPool为工作线程
mainReactorThreads为分发服务请求线程
subReactorThreads为解析数据线程。
启动服务调用newGroup初始化，将mainReactorThreads、subReactorThreads分别进行初始化，调用initAndRegister将服务通道注册到mainReactorThreads中处理。

package com.reactor;

import java.io.IOException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @Description
 * @Auth ydh
 * @Version v1.0
 * @see
 **/
abstract class ReactorThread extends Thread{

    Selector selector;
    LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();

    public abstract void handler(SelectableChannel channel) throws Exception;

    public ReactorThread() throws IOException{
        selector = Selector.open();
    }

    volatile boolean running = false;

    @Override
    public void run() {

        while(running) {
            try {
                Runnable task;
                while ((task = taskQueue.poll()) != null) {
                    task.run();
                }
                selector.select(1000);
                // 获取查询结果
                Set<SelectionKey> selected = selector.selectedKeys();
                // 遍历查询结果
                Iterator<SelectionKey> iter = selected.iterator();
                while (iter.hasNext()) {
                    // 被封装的查询结果
                    SelectionKey key = iter.next();
                    iter.remove();
                    int readyOps = key.readyOps();
                    // 关注 Read 和 Accept两个事件
                    if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                        try {
                            SelectableChannel channel = (SelectableChannel) key.attachment();
                            channel.configureBlocking(false);
                            handler(channel);
                            if (!channel.isOpen()) {
                                key.cancel(); // 如果关闭了,就取消这个KEY的订阅
                            }
                        } catch (Exception ex) {
                            key.cancel(); // 如果有异常,就取消这个KEY的订阅
                        }
                    }
                }
                selector.selectNow();
            }catch (Exception e) {

            }
        }
    }

    public SelectionKey register(SelectableChannel channel) throws  Exception{
        FutureTask<SelectionKey> futureTask = new FutureTask<SelectionKey>(()->channel.register(selector,0, channel));
        taskQueue.add(futureTask);
        return futureTask.get();
    }

    public void doStart() {
        if (!running) {
            running = true;
            start();
        }
    }


}

Reacatormain

package com.reactor;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Random;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description
 * @Auth ydh
 * @Version v1.0
 * @see
 **/
public class Reacatormain {

    private static ExecutorService workPool = Executors.newCachedThreadPool();

    private ServerSocketChannel serverSocketChannel;
    private ReactorThread[] mainReactorThreads = new ReactorThread[1];
    private ReactorThread[] subReactorThreads = new ReactorThread[8];

    public void newGroup() throws IOException {
        for (int i = 0; i < subReactorThreads.length; i++) {
            subReactorThreads[i] = new ReactorThread() {
                @Override
                public void handler(SelectableChannel channel) throws Exception {
                    SocketChannel ch = (SocketChannel) channel;
                    ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                    while (ch.isOpen() && ch.read(requestBuffer) != -1) {
                        if (requestBuffer.position() > 0) break;
                    }
                    if (requestBuffer.position() == 0) return;
                    requestBuffer.flip();
                    byte[] content = new byte[requestBuffer.limit()];
                    requestBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println(Thread.currentThread().getName() + "收到数据,来自：" + ch.getRemoteAddress());
                    // TODO 业务操作 数据库、接口...
                    workPool.submit(() -> {
                    });

                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                    while (buffer.hasRemaining()) {
                        ch.write(buffer);
                    }
                }

            };
        }
        for (int i = 0; i < mainReactorThreads.length; i++) {
            mainReactorThreads[i] = new ReactorThread() {

                AtomicInteger incr = new AtomicInteger(0);

                @Override
                public void handler(SelectableChannel channel) throws Exception {
                    ServerSocketChannel ch = (ServerSocketChannel) channel;
                    SocketChannel socketChannel = ch.accept();
                    socketChannel.configureBlocking(false);
                    int index = incr.getAndIncrement() % subReactorThreads.length;
                    ReactorThread workEventLoop = subReactorThreads[index];
                    workEventLoop.doStart();
                    SelectionKey selectionKey = workEventLoop.register(socketChannel);
                    selectionKey.interestOps(SelectionKey.OP_READ);
                    System.out.println(Thread.currentThread().getName() + "收到新连接 : " + socketChannel.getRemoteAddress());
                }
            };

        }
    }

    public void initAndRegister() throws  Exception{
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        int index = new Random().nextInt(mainReactorThreads.length);
        mainReactorThreads[index].doStart();
        SelectionKey selectionKey = mainReactorThreads[index].register(serverSocketChannel);
        selectionKey.interestOps(SelectionKey.OP_ACCEPT);
    }

    public void bind() throws IOException {
        //  1、 正式绑定端口，对外服务
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("启动完成，端口8080");
    }

}

App

package com.reactor;

import java.io.IOException;

/**
 * @Description
 * @Auth ydh
 * @Version v1.0
 * @see
 **/
public class App {

    public static void main(String[] args) throws Exception {
        Reacatormain reacatormain = new Reacatormain();
        reacatormain.newGroup();
        reacatormain.initAndRegister();
        reacatormain.bind();
    }

}
qq_32806781
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java allocate_Java中的ByteBufferallocate()方法
weixin_30572707的博客
03-04 773
可以使用java.nio.ByteBuffer类中的方法allocate()分配新的ByteBuffer。该方法需要一个参数，即缓冲区的容量。它返回分配的新的ByteBuffer。如果提供的容量为负，则抛出IllegalArgumentException。演示此的程序如下所示-示例importjava.nio.*;importjava.util.*;publicclassDemo{pub...
ByteBuffer的allocate()方法详解
热门推荐
weixin_44400390的博客
06-28 1万+
ByteBuffer的allocate()方法详解 allocate()方法用于分配缓冲区。但是如果是聚集写入,与分散读取,就需要注意这个大小设置, String property = System.getProperty("user.dir"); FileOutputStream FileOutputStream = new FileOutputStream(property ...
NIO 之 ByteBuffer实现原理
jijianshuai的专栏
08-21 3585
相关文章IO、NIO、AIO 内部原理分析 NIO 之 Selector实现原理 NIO 之 Channel实现原理前言Java NIO 主要由下面3部分组成： Buffer Channel Selector 在传统IO中，流是基于字节的方式进行读写的。 在NIO中，使用通道（Channel）基于缓冲区数据块的读写。流是基于字节一个一个的读取和写入。 通道是基于块的方式进行读取和写入。Buf
Netty——ByteBuffer（ByteBuffer的方法说明演示示例）
小志的博客
07-24 676
Netty——ByteBuffer（ByteBuffer的方法说明演示示例）
ByteBuffer使用揭秘
共勉
02-07 2171
揭秘NIO中ByteBuffer缓冲区的使用细节和常用操作场景示例
JAVA NIO学习笔记.docx
最新发布
09-02
IO 是主存和外部设备 ( 硬盘、终端和网络等 ) 拷贝数据的过程。 IO 是操作系统的底层功能实现，底层通过 I/O 指令进行完成。 所有语言运行时系统提供执行 I/O 较高级别的工具。 (c 的 printf scanf,java 的面向对象...
javaNIO学习笔记
08-22
java NIO的基本知识点学习笔记，不包含具体代码
Java NIO学习笔记——ByteBuffer用法
03-24
NULL 博文链接：https://zheng12tian.iteye.com/blog/1094811
javaNIO学习笔记（csdn）————程序.pdf
12-01
javaNIO学习笔记（csdn）————程序
nio demo for nio学习笔记（体系结构以及模块介绍）
03-22
文章同步：http://blog.csdn.net/wgyscsf/article/details/50953318
Nio学习笔记(java)
04-02
Nio学习笔记
java NIO学习系列 笔记
06-13
Contents: 1 核心概念以及基本读写 2 缓冲区的实现机制 3 连网与异步IO 4 分散和聚集IO 5 文件锁定
Redis学习笔记(全网最全)
07-09
个人学习整理的Redis笔记,全网最全。 内容包含Redis原理介绍 NIO原理介绍,类型,API,集群,持久化单机等模块。 一遍笔记就可以帮助你学会Redis,小伙伴们快学起来吧
ByteBuffer详解
一场人生，一场梦
01-10 1万+
一、前言 前一篇文章我们介绍了Android中直播视频技术的基础大纲知识，这里就开始一一讲解各个知识点，首先主要来看一下视频直播中的一个重要的基础核心类：ByteBuffer，这个类看上去都知道了，是字节缓冲区处理字节的，这个类的功能非常强大，也在各个场景都有用到，比如网络数据底层处理，特别是结合网络通道信息处理的时候，还有就是后面要说到的OpenGL技术也要用到，当然在视频处理中也是很重要
java bytes_Java Bytes 操作和类型转换 | 学步园
weixin_35764532的博客
02-12 447
public byte[] longToBytes(long x) {ByteBuffer buffer = ByteBuffer.allocate(8);buffer.putLong(x);return buffer.array();}public long bytesToLong(byte[] bytes) {ByteBuffer buffer = ByteBuffer.allocate(8)...
Netty框架内的宝藏：ByteBuf
Java技术攻略的博客
04-04 204
用来左对象引用计数的ByteBuf用来跟踪对象的分配和销毁，做自动内存回收JDK自带的ByteBuff，由于是以字节数组实现，所以定好数组长度之后不方便进行扩容，并且由于只有单个指针记录偏移量位置，所以需要程序员自己去调用API，增加了编码的难度。但是Java NIO里面的返回值和参数都是ByteBuffer形式，所以没办法，难受也得顶着。Netty实现了ByteBuf，同样也是以字节数组的形式来存数据，但是在框架的层面上帮我们封装了很多不必要的操作，并且支持了动态平滑扩容、空间复用等操作。
netty的byteBuf
wst6663017的博客
10-14 378
1.byteBuf是什么 byteBuf是netty对nio的byteBuffer的现实，因为byteBuff使用场景有限 2.byteBuf类关系图 3.为什么netty要用bytebuf来替换bytebuffer 1.使用readIndex和writeIndex来解决每次读写时需要进行flip操作的问题 简化了读写的操作，读有读的指针，写有写的指针，互补干扰 2.封装了每次put需要进行可写空...
java.nio API学习
05-01
Java NIO（New I/O）是一个可以替代标准 Java I/O API 的 Java API。NIO 提供了更快速、更高效的 I/O 操作方式，也可以进行非阻塞 I/O 操作。 下面是几个 NIO 核心类和接口： - Buffer：缓冲区，用于数据的读取和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值