网络编程之NIO(二)

淡淡的烟草味﹌ 2022-02-25 13:16 376阅读 0赞

一.NIO定义

  1. Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。学习NIO首先要知道其有两个核心,一个是ByteBuffer字节缓冲区,一个是Selector通道选择器

二.ByteBuffer字节缓冲区

1.ByteBuffer设计原理

在这里插入图片描述
2.demo测试

  1. import java.nio.ByteBuffer;
  2. /**
  3.  * Created by ${ligh} on 2019/2/22 下午4:54
  4.  *
  5.  *  图解参考 https://www.processon.com/
  6.  */
  7. public class TestBufferDemo {
  8.     public static void main(String[] args) {
  10.         //1.创建ByteBuffer
  11.         byte[] bytes = new byte[5];
  12.         ByteBuffer buffer = ByteBuffer.wrap(bytes);
  13.         showMetircs("初始化状态",buffer);  //打印结果: 0 5 5
  14.         //写入字节
  15.         buffer.put((byte) 'a');
  16.         buffer.put((byte) 'b');
  17.         showMetircs("写入两个字节之后",buffer);  //打印结果: 2 5 5
  18.         //遍历读取数据
  19.        /* while (buffer.hasRemaining()){
  20.             System.out.print(buffer.get()+" "); //读取到的是 0 0 0
  21.         }
  22.         System.out.println();*/
  24.         //为了读取到添加进去的a,b两字节,调用flip()方法
  25.         buffer.flip();
  26.         //遍历读取数据
  27.         while (buffer.hasRemaining()){
  28.             System.out.print(buffer.get()+" "); //读取到的是 97 98 此时position和limit的值都是2,不能再存储数据了,因为没有缓冲区了
  29.         }
  30.         System.out.println();
  31.         //查看此时buffer中属性的值
  32.         showMetircs("读完a,b两字节之后",buffer);   //打印结果 2 2 5 表示pos和limit的之间没有存储空间了
  33.         //调用clear()方法,然后添加字节c
  34.         buffer.clear();
  35.         buffer.put((byte)'c');
  36.         showMetircs("写完c字节之后",buffer);  //打印结果 1 5 5
  37.         //遍历添加完c字节之后的缓冲区buffer
  38.         while (buffer.hasRemaining()) {
  39.             System.out.print(buffer.get() + " ");  //读取到的数据是 98 0 0 0
  40.         }
  41.         //如果想读到新添加的字节c也就是98只需要调用flip即可
  42.     }
  43.     public static void showMetircs(String state,ByteBuffer buffer){
  44.         System.out.println(state+ " pos: "+buffer.position()+" ,limit: "+buffer.limit()+" ,capacity: "+buffer.capacity());
  45.     }
  46. }

三.Selector通道选择器

1.定义:

  1. Selector会自动把注册队列中的附件封装成一个个的SelectionKey放在事件队列中,然后一直遍历事件队列获得SelectionKey对应的通道类型或者附件,然后执行相应的IO操作类型是accept还是read或者write,最后执行完成之后把事件队列中的SelectionKey移除,注册队列不进行操作,继续监控.作用就是辅助检查Channel状态,将就绪的IO提供给线程。

2.设计原理
在这里插入图片描述
三.NIO编程套路

1.服务端:

  1. 创建ServerSocketChannel
  2. 绑定监听端口
  3. 设置通道非阻塞
  4. 创建通道选择器
  5. 注册事件类型
  6. 迭代遍历事件列表

2.客户端:

  1. 创建客户端实例 Socket s = new Socket();
  2. 连接服务器 s.connect(new InetSocketAddress(host,port));
  3. 发送请求 OutputStream out = s.getOutputStream();
  4. 获取响应 InputStream result = s.getInputStream();
  5. 关闭资源 s.close();

四.实战demo演练

1.服务端:

  1. import java.io.ByteArrayOutputStream;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.SelectionKey;
  5. import java.nio.channels.Selector;
  6. import java.nio.channels.ServerSocketChannel;
  7. import java.nio.channels.SocketChannel;
  8. import java.util.Date;
  9. import java.util.Iterator;
  10. /**
  11.  *  服务端
  12.  *
  13.  */
  14. public class NioServerBootstrap {
  15.     public static void main(String[] args) throws Exception{
  16.         //1.创建ServerSocketChannel
  17.         ServerSocketChannel ssc = ServerSocketChannel.open();
  18.         //2.绑定监听端口
  19.         ssc.bind(new InetSocketAddress(9999));
  20.         //3.设置通道非阻塞
  21.         ssc.configureBlocking(false);
  22.         //4.创建通道选择器
  23.         Selector selector = Selector.open();
  24.         //5.注册事件类型
  25.         ssc.register(selector, SelectionKey.OP_ACCEPT);
  26.         //6.遍历事件列表
  27.         while (true){
  28.             System.out.println("------我在9999-------");
  29.             int n = selector.select();
  30.             //判断是否阻塞 0表示阻塞
  31.             if(n>0){ //n大于0表示有事件需要处理
  32.                 Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
  33.                 while (iterator.hasNext()){
  34.                     //遍历获取每一个key
  35.                     SelectionKey key = iterator.next();
  36.                     //处理对应的IO事件
  37.                     if(key.isAcceptable()){
  38.                         System.out.println("------isAcceptable------");
  39.                         //获取通道
  40.                         ServerSocketChannel channel = (ServerSocketChannel) key.channel();
  41.                         //调用channel的转发
  42.                         SocketChannel socketChannel = channel.accept();//立即返回一个非null的SocketChannel
  44.                         //设置通道非阻塞
  45.                         socketChannel.configureBlocking(false);
  46.                         //注册到通道选择器注册队列
  47.                         socketChannel.register(selector,SelectionKey.OP_READ);
  48.                     }else if(key.isReadable()){
  49.                         System.out.println("------isReadable------");
  50.                         //读就绪的情况下进入
  51.                         SocketChannel channel = (SocketChannel) key.channel();
  52.                         //读事件
  53.                         //用户意图
  54.                         ByteBuffer buffer = ByteBuffer.allocate(1024);
  55.                         ByteArrayOutputStream req = new ByteArrayOutputStream();
  57.                         while (true){
  58.                             buffer.clear();
  59.                             int num = channel.read(buffer);
  60.                             if(num == -1) break;
  61.                             buffer.flip();
  62.                             req.write(buffer.array(),0,num);
  63.                         }
  64.                         channel.register(selector,SelectionKey.OP_WRITE,req);
  66.                     }else if(key.isWritable()){
  67.                         System.out.println("------isWritable-----");
  68.                         //写事件
  69.                         //获取附件
  70.                         ByteArrayOutputStream req = (ByteArrayOutputStream) key.attachment();
  71.                         ByteBuffer buffer = ByteBuffer.wrap((new Date().toLocaleString()).getBytes());
  72.                         SocketChannel channel = (SocketChannel) key.channel();
  73.                         channel.write(buffer);
  74.                         //告诉通道写结束
  75.                         channel.shutdownOutput();
  76.                         //关闭通道
  77.                         channel.close();
  78.                     }
  79.                     //移除已经处理的事件
  80.                     iterator.remove();
  81.                 }
  82.             }else {
  83.                 continue;
  84.             }
  85.         }
  86.     }
  87. }

2.客户端:

  1. import java.io.*;
  2. import java.net.InetSocketAddress;
  3. import java.net.Socket;
  4. /**
  5.  * Created by ${ligh} on 2019/2/22 上午10:08
  6.  *
  7.  * 在NIO中服务端不一样,但是客户端几乎都是差不多的
  8.  *
  9.  * 客户端
  10.  */
  11. public class Clientbootstrap {
  12.     public static void main(String[] args) throws Exception{
  13.         //1. 创建客户端实例
  14.         Socket s = new Socket();
  15.         //2. 连接服务器
  16.         s.connect(new InetSocketAddress("127.0.0.1",9999));
  17.         //3. 发送请求
  18.         OutputStream out = s.getOutputStream();
  19.         PrintWriter pw = new PrintWriter(out);
  20.         pw.println("你好,我是客户端...");
  21.         pw.flush();
  23.         //告诉服务器 写结束
  24.         s.shutdownOutput();
  25.         //4. 获取响应
  26.         InputStream result = s.getInputStream();
  27.         InputStreamReader isr= new InputStreamReader(result);
  28.         BufferedReader reader= new BufferedReader(isr);
  30.         //读取响应
  31.         String line = null;
  32.         StringBuffer sb = new StringBuffer();
  33.         while ((line = reader.readLine())!=null){
  34.             sb.append(line);
  35.         }
  36.         System.out.println("客户端收到: "+sb.toString());
  37.         //5. 关闭资源
  38.         s.close();
  39.     }
  40. }

五.拓展
通过NIO实现文件的拷贝,具体demo如下:

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.FileChannel;
  5. /**
  6.  * Created by ${ligh} on 2019/2/22 下午5:18
  7.  *
  8.  */
  9. public class TestFileCopy {
  10.     public static void main(String[] args) throws Exception{
  12.        // testWrite();
  13.        // testRead();
  14.         testCopy();
  15.     }
  16.     /**
  17.      *  写文件
  18.      *
  19.      *  特点:
  20.      *    应用 --> ByteBuffer --> 通道 --> 磁盘   应用将数据传到ByteBuffer中,然后通过通道将数据写到磁盘中
  21.      *
  22.      * @throws Exception
  23.      */
  24.     public static void testWrite() throws Exception{
  26.         //所写入文件中的位置
  27.         FileOutputStream fos = new FileOutputStream("aa.txt");
  29.         //创建缓冲区
  30.         ByteBuffer buffer = ByteBuffer.wrap(new byte[1024]);
  32.         //创建通道
  33.         FileChannel channel = fos.getChannel();
  35.         //向缓冲区中存储数据
  36.         buffer.put("hello world!".getBytes());
  37.         //读到刚存进缓冲区中的数据
  38.         buffer.flip();
  40.         //写入到通道中
  41.         channel.write(buffer);
  43.         //关闭资源
  44.         channel.close();
  45.         fos.close();
  46.     }
  48.     /**
  49.      *  读文件
  50.      *
  51.      *  特点:
  52.      *      磁盘 --->  通道  ---> ByteBuffer中 ---> 应用   磁盘数据通过通道写入到ByteBuffer中,然后应用从ByteBuffer中拿读取数据
  53.      * @throws Exception
  54.      */
  55.     public static void testRead() throws Exception{
  56.         //要读取的文件
  57.         FileInputStream fis = new FileInputStream("aa.txt");
  59.         //创建通道
  60.         FileChannel inchannel = fis.getChannel();
  62.         //创建缓冲区
  63.         ByteBuffer buffer = ByteBuffer.wrap(new byte[1024]);
  65.         //通道读取数据到buffer中,相当于存储到其中
  66.         int i = inchannel.read(buffer);
  68.         buffer.flip();
  70.         //获取buffer中的数据
  71.         System.out.println(new String(buffer.array(),0,i));
  73.         //关闭资源
  74.         inchannel.close();
  75.         fis.close();
  76.     }
  78.     /**
  79.      * 文件的拷贝
  80.      *
  81.      *  实际就是边读边写
  82.      *
  83.      * @throws Exception
  84.      */
  85.     public static void testCopy()throws Exception{
  87.         FileInputStream fis = new FileInputStream("aa.txt");
  88.         FileOutputStream fos = new FileOutputStream("bb.txt");
  90.         //创建通道
  91.         FileChannel inchannel = fis.getChannel();
  92.         FileChannel outchannel = fos.getChannel();
  94.         //创建ByteBuffer
  95.         ByteBuffer buffer = ByteBuffer.wrap(new byte[1024]);
  97.         //开始读取文件,直到读完为止
  98.         while (true){
  99.             //每次读之前首先要调用clear方法
  100.             buffer.clear();
  101.             int i = inchannel.read(buffer);
  102.             //如果i等于-1就表示已经读完,否则就继续读
  103.             if(i == -1) break;
  105.             buffer.flip();
  106.             //写出到文件中
  107.             outchannel.write(buffer);
  108.         }
  109.         //关闭资源
  110.         inchannel.close();
  111.         outchannel.close();
  112.         fis.close();
  113.         fos.close();
  114.     }
  115. }

总结
原来的BIO是一种多线程阻塞的IO,非常消耗资源,由此产生了NIO,这个单线程阻塞,多线程畅通的IO,单线程阻塞情况是通道选择器中的事件队列为空的情况下,所以不会消耗很多资源,因此是一种理想化的IO处理方式,但是,为了开发简单快捷,还是不建议使用,因此由此产生了NIO的框架Netty/Mina,一种便捷式的开发框架,具体介绍请看下一篇。

发表评论

表情：
评论列表 （有 0 条评论，376人围观）

还没有评论，来说两句吧...

相关阅读

    相关 网络编程之NIO(二)

    一.NIO定义     Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 377 阅读