java网络编程系列之JavaIO的“今生”：NIO非阻塞模型

转x33g5p2x  于2021-12-30 转载在 Java  
字(5.5k)|赞(0)|评价(0)|浏览(519)

BIO中的阻塞

非阻塞式NIO

  • Channel: Channel 和 IO 中的 Stream(流)是差不多一个等级的。只不过 Stream 是单向的，譬如：InputStream, OutputStream。并且Channel是非阻塞式的。

Channel与Buffer

通道可以用来读取和写入数据，通道类似于之前的输入/输出流，但是程序不会直接操作通道的，所有的内容都是先读到或写入到缓冲区中，再通过缓冲区中取得获写入的。

剖析Buffer

向Buffer中写入数据

此时读取分为两种情况:

  • 一次性将写入的数据全部读取出来

  • 读取数据时，读取数据到一半，希望转换为写入模式,但是又不希望丢掉还没有读取完毕的数据

剖析channel

  • channel可以通过buffer读取和写入数据
  • 两个channel之间也可以直接进行数据间的传输

几个重要的channel

多方法实现本地文件拷贝

通用的关闭流方法

  1. //通用关闭流和通道的方法
  2.     //所有可以被关闭的流和通道都实现了Closeable接口
  3.     public static void close(Closeable closeable)
  4.     {
  5.         if(closeable!=null)
  6.         {
  7.             try {
  8.                 closeable.close();
  9.             } catch (IOException e) {
  10.                 e.printStackTrace();
  11.             }
  12.         }
  13.     }
字节输入流拷贝文件
  1. //字节流拷贝文件实现
  2.       public static void noBufferStreamCopy(File src, File tar)
  3.       {
  4.           InputStream in=null;
  5.           OutputStream out=null;
  6.           try
  7.           {
  8.               in=new FileInputStream(src);
  9.               out=new FileOutputStream(tar);
  11.               //每次读取一个字节
  12.               Integer len;
  13.               //文件读取完毕返回-1
  14.               while((len=in.read())!=-1)
  15.               {
  16.                   out.write(len);
  17.               }
  18.           }
  19.           catch (FileNotFoundException e) {
  20.               e.printStackTrace();
  21.           } catch (IOException e) {
  22.               e.printStackTrace();
  23.           }finally {
  24.               close(in);
  25.               close(out);
  26.           }
  27.       }
字节缓冲流拷贝文件
  1. //字节缓冲流拷贝文件实现
  2.      public static void bufferStreamCopy(File src,File tar)
  3.      {
  4.          BufferedInputStream bis=null;
  5.          BufferedOutputStream bos=null;
  6.          //使用装饰器模式
  7.          try {
  9.               bis = new BufferedInputStream(new FileInputStream(src));
  10.              bos=new BufferedOutputStream(new FileOutputStream(tar));
  11.              //准备一个缓存区，大小为1024个字节
  12.              byte[] buffer=new byte[1024];
  13.              int len;
  14.              //一次性读取1024个字节
  15.              while((len=bis.read(buffer))!=-1)
  16.              {
  17.                 bos.write(buffer,0,len);
  18.              }
  20.          } catch (FileNotFoundException e) {
  21.              e.printStackTrace();
  22.          } catch (IOException e) {
  23.              e.printStackTrace();
  24.          }finally {
  25.              close(bis);
  26.              close(bos);
  27.          }
  28.      }
FileChannel拷贝文件
  1. //FileChannel拷贝文件
  2.         public static void nioBufferCopy(File src,File tar)
  3.         {
  4.             FileChannel fin=null;
  5.             FileChannel fout=null;
  6.             try {
  7.                 fin=new FileInputStream(src).getChannel();
  8.                  fout=new FileOutputStream(tar).getChannel();
  9.                //准备一个缓冲区
  10.                 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  11.                 while(fin.read(byteBuffer)!=-1)//将数据写入缓冲区，一次最多写入1024个字节
  12.                 {
  13.                     //将当前缓冲区从写模式转换为读模式
  14.                     byteBuffer.flip();
  15.                     //一直读取到缓冲区没有数据剩余为止
  16.                     while (byteBuffer.hasRemaining())
  17.                     {
  18.                         //从缓冲区中读取数据，写入通道中
  19.                         fout.write(byteBuffer);
  20.                     }
  21.                     //将当前缓冲区从读模式转换为写模式
  22.                     byteBuffer.clear();
  23.                 }
  24.             } catch (FileNotFoundException e) {
  25.                 e.printStackTrace();
  26.             } catch (IOException e) {
  27.                 e.printStackTrace();
  28.             }finally {
  29.                 close(fin);
  30.                 close(fout);
  31.             }
  32.         }
通道间的数据传输完成文件拷贝—transferto,transferfrom
  1. //通道间传输完成文件拷贝
  2.      public static void nioTransferCopy(File src,File tar)
  3.      {
  4.          FileChannel fin=null;
  5.          FileChannel fout=null;
  6.          try {
  7.              fin=new FileInputStream(src).getChannel();
  8.              fout=new FileOutputStream(tar).getChannel();
  9.              //记录当前总共传输的字节数
  10.              Long transferredBytes= 0L;
  11.              //记录需要拷贝文件的字节总数
  12.              Long size=fin.size();
  13.              
  14.              while(transferredBytes!=size)
  15.              {
  16.                  //transferTo函数每次返回当前总共拷贝了多少个字节
  17.                  transferredBytes+=fin.transferTo(0,size,fout);
  18.              }
  19.              
  20.          } catch (IOException e) {
  21.              e.printStackTrace();
  22.          }
  23.          finally {
  24.              close(fin);
  25.              close(fout);
  26.          }
  27.      }

文件拷贝的完整源码

  1. public class Main
  2. {
  3.     public static void main(String[] args) {
  4.         final String prefix=System.getProperty("user.dir")+System.getProperty("file.separator");
  5.         File src=new File(prefix+"src.txt");
  6.         File tar=new File(prefix+"tar.txt");
  7.         //测试字节流拷贝文件
  8.      CopyFile.nioTransferCopy(src,tar);
  9.     }
  11.     public static class CopyFile
  12.     {
  13.      //字节流拷贝文件实现
  14.       public static void noBufferStreamCopy(File src, File tar)
  15.       {
  16.           InputStream in=null;
  17.           OutputStream out=null;
  18.           try
  19.           {
  20.               in=new FileInputStream(src);
  21.               out=new FileOutputStream(tar);
  23.               //每次读取一个字节
  24.               Integer len;
  25.               //文件读取完毕返回-1
  26.               while((len=in.read())!=-1)
  27.               {
  28.                   out.write(len);
  29.               }
  30.           }
  31.           catch (FileNotFoundException e) {
  32.               e.printStackTrace();
  33.           } catch (IOException e) {
  34.               e.printStackTrace();
  35.           }finally {
  36.               close(in);
  37.               close(out);
  38.           }
  39.       }
  40.      //字节缓冲流拷贝文件实现
  41.      public static void bufferStreamCopy(File src,File tar)
  42.      {
  43.          BufferedInputStream bis=null;
  44.          BufferedOutputStream bos=null;
  45.          //使用装饰器模式
  46.          try {
  48.               bis = new BufferedInputStream(new FileInputStream(src));
  49.              bos=new BufferedOutputStream(new FileOutputStream(tar));
  50.              //准备一个缓存区，大小为1024个字节
  51.              byte[] buffer=new byte[1024];
  52.              int len;
  53.              //一次性读取1024个字节
  54.              while((len=bis.read(buffer))!=-1)
  55.              {
  56.                 bos.write(buffer,0,len);
  57.              }
  59.          } catch (FileNotFoundException e) {
  60.              e.printStackTrace();
  61.          } catch (IOException e) {
  62.              e.printStackTrace();
  63.          }finally {
  64.              close(bis);
  65.              close(bos);
  66.          }
  67.      }
  68.      //FileChannel拷贝文件
  69.         public static void nioBufferCopy(File src,File tar)
  70.         {
  71.             FileChannel fin=null;
  72.             FileChannel fout=null;
  73.             try {
  74.                 fin=new FileInputStream(src).getChannel();
  75.                  fout=new FileOutputStream(tar).getChannel();
  76.                //准备一个缓冲区
  77.                 ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
  78.                 while(fin.read(byteBuffer)!=-1)//将数据写入缓冲区，一次最多写入1024个字节
  79.                 {
  80.                     //将当前缓冲区从写模式转换为读模式
  81.                     byteBuffer.flip();
  82.                     //一直读取到缓冲区没有数据剩余为止
  83.                     while (byteBuffer.hasRemaining())
  84.                     {
  85.                         //从缓冲区中读取数据，写入通道中
  86.                         fout.write(byteBuffer);
  87.                     }
  88.                     //将当前缓冲区从读模式转换为写模式
  89.                     byteBuffer.clear();
  90.                 }
  91.             } catch (FileNotFoundException e) {
  92.                 e.printStackTrace();
  93.             } catch (IOException e) {
  94.                 e.printStackTrace();
  95.             }finally {
  96.                 close(fin);
  97.                 close(fout);
  98.             }
  99.         }
  100.      //通道间传输完成文件拷贝
  101.      public static void nioTransferCopy(File src,File tar)
  102.      {
  103.          FileChannel fin=null;
  104.          FileChannel fout=null;
  105.          try {
  106.              fin=new FileInputStream(src).getChannel();
  107.              fout=new FileOutputStream(tar).getChannel();
  108.              //记录当前总共传输的字节数
  109.              Long transferredBytes= 0L;
  110.              //记录需要拷贝文件的字节总数
  111.              Long size=fin.size();
  113.              while(transferredBytes!=size)
  114.              {
  115.                  //transferTo函数每次返回当前总共拷贝了多少个字节
  116.                  transferredBytes+=fin.transferTo(0,size,fout);
  117.              }
  119.          } catch (IOException e) {
  120.              e.printStackTrace();
  121.          }
  122.          finally {
  123.              close(fin);
  124.              close(fout);
  125.          }
  126.      }
  127.     }
  129.     //通用关闭流和通道的方法
  130.     //所有可以被关闭的流和通道都实现了Closeable接口
  131.     public static void close(Closeable closeable)
  132.     {
  133.         if(closeable!=null)
  134.         {
  135.             try {
  136.                 closeable.close();
  137.             } catch (IOException e) {
  138.                 e.printStackTrace();
  139.             }
  140.         }
  141.     }
  142. }

文件拷贝测试结果

对于小文件拷贝而言，nio优势也还可以，对于大文件而言，nio的优势相对比较明显，并且大家要注意缓冲区大小的选择

剖析Selector

  • 简而言之Selector可以帮助我们监控多个通道的状态
  • 想让Selector监控对应的channel，首先需要把需要被监控的channel注册在Selector上面

在Selector上面注册三个Channel

channel的状态变化

channel可以在上面四个状态中来回切换

在selector上面注册channel

SelectionKey:该对象可以作为当前注册在selector上的channel的唯一标识，通过这个对象也可以获取到当前channel的一些信息

下面展示SelectionKey对象的一些方法:

  • interestOps():返回当前channel在selector上面注册的状态
  • readyOps():返回当前channel的有哪些被监听的状态是处于准备好的，可操作的状态
  • channel():返回selectionkey指代的channel对象
  • selector():返回的是当前channel是在哪一个selector上进行的注册
  • attachment():关于channel的附加信息

使用selector选择channel

  • 第一个channel注册在selector上，并且让selector只去监听当前channel的connect状态
  • 后面两个同理

通过select()函数可以返回当前处于可操作状态下的channel

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/121767106

内容来源于网络，如有侵权，请联系作者删除！

Javanio网络开发语言

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com