NIO学习二、NIO的基本使用

最新推荐文章于 2022-11-21 14:18:12 发布
最新推荐文章于 2022-11-21 14:18:12 发布
阅读量268 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zq17865815296/article/details/78704300
版权

这是作为学习NIO的总结，如有不对，请大佬指出。

一、基本操作（这些操作不会的时候查文档就行）

     从一个buffer中读写到另一个buffer

    @Test
    public void bufferTest1(){
        try {
            RandomAccessFile readAccessFile=new RandomAccessFile("C:\\Users\\e550c\\Desktop\\日结.txt","rw");
            RandomAccessFile writeAccessFile=new RandomAccessFile("C:\\Users\\e550c\\Desktop\\temp.txt","rw");

            FileChannel readChannel=readAccessFile.getChannel();
            FileChannel writeChannel=writeAccessFile.getChannel();
            //将一个channel数据送入另一个channel(这样做可以实现文件的写入)
            //与之相对的是transferFrom
            readChannel.transferTo(0,readAccessFile.length(), writeChannel);

            readAccessFile.close();
            writeAccessFile.close();;

        } catch (FileNotFoundException e) {


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 其他常见的：
  Buffer.rewind()将position设回0，所以你可以重读Buffer中的所有数据。             
  mark()与reset()方法 通过调用Buffer.mark()方法，可以标记Buffer中的
  一个特定position。之后可以通过调用Buffer.reset()方法恢复到这个position。

二、Scatter与Gather

        scatter：是将channel中的数据写入到多个buffer中，先写满第一个，然后写入下一个：
        Gater：将多个buffer数据先聚集在一起，然后写入到指定的buffer中。

       try {
            ByteBuffer byteBuffer1=ByteBuffer.allocate(10);
            ByteBuffer byteBuffer2=ByteBuffer.allocate(10);
            RandomAccessFile randomAccessFile=new RandomAccessFile("C:\\Users\\e550c\\Desktop\\temp.txt","rw");
            byteBuffer1.clear();
            byteBuffer2.clear();
            byteBuffer1.put("hello".getBytes());
            byteBuffer2.put("OK,world".getBytes());
            byteBuffer1.flip();
            byteBuffer2.flip();
            FileChannel fileChannel=randomAccessFile.getChannel();
            //将多个byteBuffer聚集在一起写入
            fileChannel.write(new ByteBuffer[]{byteBuffer1,byteBuffer2});

            byteBuffer1.clear();
            byteBuffer2.clear();
            fileChannel.position(0L);
            //先写满第一个，第一个满后再写入第二个
            fileChannel.read(new ByteBuffer[]{byteBuffer1,byteBuffer2});
            byteBuffer1.flip();
            while(byteBuffer1.hasRemaining()){
                System.out.print((char)byteBuffer1.get());
            }
            System.out.println();
            byteBuffer2.flip();
            while(byteBuffer2.hasRemaining()){
                System.out.print((char)byteBuffer2.get());
            }
            fileChannel.close();
            randomAccessFile.close();
        }catch (Exception e){
            e.printStackTrace();;
        }

三、非阻塞IO操作

    所有的非阻塞IO的channel都实现了SelectableChannel接口，而FileChannle没有实现这个接口，所以它不支持非阻塞IO
     以一个ServerSocketChannel与SocketChannel为例子来演示：不懂的话可以先看看java网络编程。

      服务端代码：
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

            serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1", 1234));//监听1234端口
            serverSocketChannel.configureBlocking(false);//这样配置后就是同步非阻塞的

            SocketChannel socketChannel = null;
            while ((socketChannel = serverSocketChannel.accept()) == null) {//如果没有客户端连接的话立即返回
                System.out.println("try to Linking:");               //不会阻塞
                TimeUnit.SECONDS.sleep(1);
            }
            ByteBuffer byteBuffer1 = ByteBuffer.allocate(10);
            ByteBuffer byteBuffer2 = ByteBuffer.allocate(10);
            socketChannel.read(new ByteBuffer[]{byteBuffer1, byteBuffer2});

            byteBuffer1.flip();//回到初始位置
            byteBuffer2.flip();
            while (byteBuffer1.hasRemaining()) {
                System.out.println((char) byteBuffer1.get());
            }
            System.out.println("-----------------");
            while (byteBuffer2.hasRemaining()) {
                System.out.println((char) byteBuffer2.get());
            }
            socketChannel.close();//读取完之后手动关闭这个连接
            serverSocketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
客户端代码
          SocketChannel socketChannel=null;
        try {
            socketChannel=SocketChannel.open();//打开socket
            socketChannel.connect(new InetSocketAddress("127.0.0.1",1234));//连接上指定服务端口
            ByteBuffer byteBuffer1=ByteBuffer.allocate(12);
            ByteBuffer byteBuffer2=ByteBuffer.allocate(12);
            byteBuffer1.put("hello,world".getBytes());

            byteBuffer1.flip();

            byteBuffer2.put("hello,next".getBytes());
            byteBuffer2.flip();

            socketChannel.write(byteBuffer1);
            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

四、Piple管道操作：

       Java NIO管道是两个线程之间单项的数据连接。Piple有一个source通道和一个sink通道。数据会被写到sink通道，从source通道中读取。

    /*
    * Piple进行管道
    * */
    @Test
    public void test16(){
        try {
            //创建一个piple通道
            Pipe pipe=Pipe.open();
            //创建一个写通道
            WritableByteChannel writableByteChannel=pipe.sink();
            //c创建一个读通道，从读通道中获取数据
            ReadableByteChannel readableByteChannel=pipe.source();


            //创建一个线程从sink写入数据
            WorkerThread workerThread=new WorkerThread(writableByteChannel);
            workerThread.start();
            ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
            while(readableByteChannel.read(byteBuffer)>=0){
                byteBuffer.flip();
                byte[] bytes=new byte[byteBuffer.remaining()];

                byteBuffer.get(bytes);
                String str=new String(bytes);
                System.out.println(str);
                byteBuffer.clear();
            }
            readableByteChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }



    private static class WorkerThread  extends Thread{
        WritableByteChannel writableByteChannel;
        public WorkerThread(WritableByteChannel writableByteChannel){
            this.writableByteChannel=writableByteChannel;
        }

        @Override
        public void run() {
            ByteBuffer byteBuffer=ByteBuffer.allocate(1024);
            for (int i=0;i<10;i++){
                String str="piple sink data"+i;
                byteBuffer.put(str.getBytes());
                byteBuffer.flip();

                try {
                    writableByteChannel.write(byteBuffer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                byteBuffer.clear();
            }
            try{
                writableByteChannel.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

五、Selector操作（最重要的，压轴的&&&）

 channle与selector适配使用的，创建了非阻塞的channel之后，注册到selector中，返
   回注册的SelectionKey，并设置感兴趣的事件，也就是说当这些事件发生的时候，对应的
   Channel就准备就绪，可以使用。如果没有发生，那么就等待。
 ps:有时候感觉channel出现很突兀，是因为selector 直接管理 Java Socket 很难实现
   ，所以使用channel做一次封装与之适配。这一切都是为了selector而存在的。
如下所示：

serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
感兴趣的事件是通过SelectionKey来获得：有如下四种：
      SelectionKey.OP_ACCEPT —— 接收连接继续事件，表示服务器监听到了客户连接，
      服务器可以接收这个连接了
      SelectionKey.OP_CONNECT —— 连接就绪事件，表示客户与服务器的连接已经建立成功
      SelectionKey.OP_READ--读就绪事件，表示可以读了（通道目前有数据，可以进行读操作了）
      SelectionKey.OP_WRITE —— 写就绪事件，表示已经可以向通道写数据了（通道目前可
      以用于写操作）
      操作了（通道目前有数据，可以进行读操作了）
selector中两个重要的函数：          
      selector.select():返回当前就绪的channel数量，如果没有就绪channel，那么它就
      阻塞，直到就绪channel将它唤醒。            
            其他的select（）：
            select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。 
            selectNow()不会阻塞，不管什么通道就绪都立刻返回（此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，
            则此方法直接返回零）。
     selector.SelectionKey()：返回已经准备就绪的channel注册标记的set集合，单个
     SelectionKey通过channel()为此对应的SelectionKey创建通道.其他操作查文档就好了。

呼呼~~~~接下来是一个例子：仍然以ServerSocketChannel与SocketChannel为例子：

//服务端：
          try {
            ServerSocketChannel serverSocketChannel=ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1",1234));
            //设置非阻塞状态
            serverSocketChannel.configureBlocking(false);
            //创建一个Selector
            Selector selector=Selector.open();
            //将serverSocketChannel注册到selecor中，它的返回值为对应的SelectionKey
            //它对ACCPET事件感兴趣，也就是说当客户端连接的时候，它准备就绪，可以被Selector调用
            serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
            //分配空间
            ByteBuffer byteBuffer=ByteBuffer.allocate(128);
            while(true){
                //如果没有就绪事件，它就阻塞
                int n=selector.select();
                //获取就绪的channel对应的注册标记集合
                Set<SelectionKey> set=selector.selectedKeys();
                Iterator<SelectionKey> iterator=set.iterator();
                while(iterator.hasNext()){
                    SelectionKey selectionKey=iterator.next();
                    //注意当得到一个SelectionKey之后必须移除它，不然会陷入死循环
                    iterator.remove();
                    if (selectionKey.isAcceptable()){
                        //触发accpet之后，它会将连接的SocketChannel注册到register中
                        //它感兴趣的事件是读事件，当通道中有数据之后，它准备就绪
                        //SocketChannel必须是同步非阻塞的
                        SocketChannel socketChannel=serverSocketChannel.accept();
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector,SelectionKey.OP_READ);
                    }else if (selectionKey.isReadable()){
                        SocketChannel socketChannel= (SocketChannel) selectionKey.channel();

                        byteBuffer.clear();
                        socketChannel.read(byteBuffer);
                        byteBuffer.flip();
                        while(byteBuffer.hasRemaining()){
                            System.out.print((char)byteBuffer.get());

                        }
                        System.out.println();
                        socketChannel.close();
                    }

                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        }  
//客户端
            SocketChannel socketChannel = null;

            try {
                socketChannel = SocketChannel.open();

                socketChannel.connect(new InetSocketAddress("127.0.0.1", 1234));
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                byteBuffer.put("hello,world".getBytes());
                byteBuffer.flip();
                socketChannel.write(byteBuffer);
                socketChannel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

另外：针对UDP的数据传输，文件锁等等等，不是全部能写完的，多看文档，多练~~

大多多
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高性能：干货分享——让你快速掌握《NIO》
weixin_44829998的博客
06-27 227
一、概述 NIO主要有三大核心部分：Channel(通道)、Buffer(缓冲区)、 Selector。 NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需...
java的nio的使用示例分享
09-04
使用NIO和NIO.2需要一定的学习曲线，但一旦掌握，它们可以在适当的情境下带来显著的性能提升，尤其在处理高并发、大文件操作或需要实时响应文件系统事件的场景中。在实际应用中，开发者应根据项目需求和性能测试结果...
NIO的基本使用
Yuan_CSDF的博客
04-20 479
1.单线程处理客户端请求 public class Server { public static void main(String[] args) throws IOException { // 通道是双向的。可以同时读写 ServerSocketChannel ssc = ServerSocketChannel.open(); ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8888))
NIO的介绍及使用(总结)
菜鸟腾飞
11-13 5910
传统的socket IO中，需要为每个连接创建一个线程，当并发的连接数量非常巨大时，线程所占用的栈内存和CPU线程切换的开销将非常巨大。使用NIO，不再需要为每个线程创建单独的线程，可以用一个含有限数量线程的线程池，甚至一个线程来为任意数量的连接服务。由于线程数量小于连接数量，所以每个线程进行IO操作时就不能阻塞，如果阻塞的话，有些连接就得不到处理，NIO提供了这种非阻塞的能力。小量的线程如何同时为
NIO 的使用
qq_58631644的博客
10-06 514
由于传统的 IO 流在实际运行时效率较低，所以 JDK 4 版本中提出了 NIO 技术，带来了可观的性能提升。NIO ：Non-Blocking IO，指的是非阻塞的 IO。传统的流式 IO ，又可以称为 BIO (Blocking IO) 阻塞 IO。🤔 如何理解阻塞与非阻塞呢？比如私家车和出租车，私家车买回来后只能是车主一家可以使用，不用的时候停在小区地库或是停在公共停车场，其他不相干的人是不能做这辆车的，这样私家车处于阻塞状态，车门锁上其他人是不能进入的；
JAVA NIO学习笔记.docx
最新发布
09-02
IO 是主存和外部设备 ( 硬盘、终端和网络等 ) 拷贝数据的过程。 IO 是操作系统的底层功能实现，底层通过 I/O 指令进行完成。 所有语言运行时系统提供执行 I/O 较高级别的工具。 (c 的 printf scanf,java 的面向对象...
Java NIO详解（学习资料）
06-20
而Java NIO通过使用通道（Channels）和缓冲区（Buffers）来改善这一情况。 在Java NIO中，数据总是从通道读取到缓冲区，然后从缓冲区写入到通道。这种方式允许I/O操作与CPU其他任务并行执行，提高了系统的整体效率...
NIO 学习文档
11-15
绝无仅有的讲的很好的NIO的学习资料。精简，明了。如果你想要，请下载，甚至可以留下联系方式，我再私信你一些。
Java NIO学习资料+代码.zip
07-07
Java NIO学习资料+代码.zip
浅谈java中nio的使用方式
08-03
NIO其核心概念包括Channel,Selector,SelectionKey,Buffer.
看了就能懂的NIO使用深入详解
Blue92120的博客
11-21 777
通过SelectionKey的 SelectableChannel channel()方法，可以获取当前 SelectionKey的表示的通道。通过SelectionKey的 Selector selector() 方法，可以获取当前 SelectionKey的绑定的选择器。通过SelectionKey的 int readyOps()方法，可以获取当前 SelectionKey的准备就绪事件。理解 Channel理解为通道,包含了写入和读取的操作,可以理解为IO中的流对象。打开异步服务器套接字通道。
NIO入门与基本使用
李豆豆的博客
06-15 256
感谢易学好文。以下均来自https://www.e-learn.cn/content/qita/674902 文章内容的学习与实践。 package test.nio; import java.io.*; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.MappedByteBuffer; impor...
NIO使用方法
雪落无痕
03-03 574
NIO进行服务端开发的一般步骤： 创建一个ServerSocketChannel，并配置它为非阻塞模式； 绑定监听，配置相关的TCP参数，比如backlog大小； 创建一个独立的I/O进程，用于轮询多路复用器Selector 创建Selector，将之前创建的ServerSocketChannel注册到Selector上，监听SelectionKey.ACCEPT事件 启动I/O线程,在一个循环体中
NIO的详细使用
qq_44002865的博客
08-11 1690
NIO 文章目录NIO1、概述Java NIO 简介Java NIO 与 IO 的主要区别2、缓冲区（Buffer）简介缓冲区的基本属性Buffer 的常用方法缓冲区的数据操作方法常用方法的使用直接与非直接缓冲区3、通道（Channel）简介Channel 接口提供的最主要实现类获取通道FileChannel 的常用方法通道的数据传输利用通道完成文件的复制使用本地文件进行传输使用TCP进行传输使用直接缓冲区完成文件的复制通道之间的数据传输transferFrom()transferTo()分散(Scatte
学习NIO 之 使用方法
weixin_30457465的博客
07-06 77
学习NIO 之 使用方法 一丶什么是NIO 　　NIO是非阻塞IO, 也可以说是新IO.在读写时并不会阻塞. 二丶同步与异步, 阻塞与非阻塞 　　同步, 一个任务的完成依赖于另一个任务的完成, 需要等待另一个任务的完成, 才能执行本任务. 　　异步, 一个任务的完成不依赖另一个任务的完成,无须等待. 　　阻塞, 是相对于CPU来说的, 挂起当前线程. 　　非阻塞, 无...
NIO的理解和使用
cheng的博客
04-02 1252
一、概述 NIO是 non-blocking-io的简称，非阻塞IO，由于它是后续出来的IO模型，有时也叫做 new-IO。NIO是后续比如React等的多路复用的基础模型。它是UNIX的五种IO模型中的一种。 NIO有三大组件：buffer、channel和selector，这三大组件共同作用，提供了多路复用的非阻塞解决方案。 二、组件一-buffer buffer是NIO中的顶层缓冲抽象类，在NIO中的buffer存储的是基本类型，但是除了Boolean类型，如下 初始化一个buffer，它的posi
java nio使用方法（转）
yyguy的博客
06-23 453
I/O即输入输出，指的是计算机和外界的接口，或者是单个程序同计算机其他部分的接口。在Java1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统每次处理一个字节，输入流（inputstream）生产一个字节，输出流（outputstream）消费一个字节。这种工作模式下，非常容易给流数据创建过滤器（filters），而且也很容易将多个过滤器串起来，每个过滤器针对流过自己的字节做相应处...
NIO详解及应用(一)
是我的温柔啊
03-01 906
一、基础详解 1、传统IO(BIO) 传统IO是面向流的，是同步阻塞式IO。每次socket请求都需要对应一个线程去处理，如果没有足够的线程处理，要么请求就是在等待，要么被拒绝。也就是每一个连接，都要求服务对应一个线程去处理。这也就是传统IO效率低下的原因。 2、NIO(NIO 1.0或New IO或 Non Blocking IO) 因为传统IO效率低下，因此在JDK1.4及以后版本中提供了一套API来专门操作非阻塞I/O，它可以替代标准的Java IO API。 注：传统的的I/O包已经使用NIO重新
Java nio使用例子
06-02
下面是一个简单的 Java NIO 示例，展示了如何使用 NIO 读取文件： ```java import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.Path; import ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值