Netty学习01--NIO

拼搏现实的明天。 2023-02-17 08:54 51阅读 0赞

**1.1 简介**

java.nio 全称 java non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO） ，为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，使用它可以提供非阻塞式的高伸缩性网络。

**1.2 为什么需要NIO**

在 java 最初的 IO 中，OutputStream 和 InputStream 没有提供异步的的 IO 读写，并且服务器端的 accept() 方法是阻塞的。这意味着在客户端中需要采用一个线程对应一个客户端连接的策略来保证服务器可以同时接受来自多个客户端的连接。这就会导致大量的系统开销和负担。这种阻塞的通信模式也正是 NIO 所要解决的主要问题！

**1.3 NIO 和 IO 的区别**

![20200613112418142.png][]

**2.1 Channel（通道）**

Java NIO 的通道类似流，但又有些不同：

\* 通道既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。

\* 通道可以异步地读写。

\* 通道中的数据总是要先读到一个 Buffer，或者总是要从一个 Buffer 中写入。

Java NIO中最重要的通道的实现：

\*FileChannel 从文件中读写数据。

\*DatagramChannel 能通过UDP读写网络中的数据。

\*SocketChannel 能通过TCP读写网络中的数据。

\*ServerSocketChannel 可以监听新进来的 TCP 连接，像 Web 服务器那样。对每一个新进来的连接都会创建一个 SocketChannel。

**2.2 Buffer（缓冲区）**

Java NIO 中的 Buffer 用于和 NIO 通道进行交互。如你所知，数据是从通道读入缓冲区，从缓冲区写入到通道中的。

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成 NIO Buffer 对象，并提供了一组方法，用来方便的访问该块内存。

Java NIO 有以下Buffer类型：

ByteBuffer、MappedByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer上述缓冲区覆盖了通过 I/O 发送的基本数据类型：character、double、int、long、byte、short 和 float。

**2.3 Selector（选择器）**

选择器是 Java NIO 中能够检测一到多个 NIO 通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个 channel，从而管理多个网络连接。

**3.1 Java NIO: 单线程管理多个连接**

NIO 可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。

如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。

（如图所示，相当于一个服务员服务多个客人）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70][]

**3.2 Java IO: 单线程管理单个连接**

如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。

（如图所示，相当于一个服务员服务一个客人）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 1][]

**4.1 传统IO代码介绍**

package com.cxb.OIO;
    
    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;
    
    /**
     * 传统socket服务端
     */
    public class OioServer {
    
        @SuppressWarnings("resource")
        public static void main(String[] args) throws Exception {
            // 使用线程池 一个线程处理一个客户端
            ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
            //创建socket服务,监听10101端口
            ServerSocket server = new ServerSocket(8001);
            System.out.println("服务器启动！");
            while (true) {
                //获取一个套接字（阻塞）
                final Socket socket = server.accept();
                System.out.println("来了一个新客户端！");
                newCachedThreadPool.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        //业务处理
                        handler(socket);
                    }
                });
    
            }
        }
    
        /**
         * 读取数据
         *
         * @param socket
         * @throws Exception
         */
        public static void handler(Socket socket) {
            try {
                byte[] bytes = new byte[1024];
                InputStream inputStream = socket.getInputStream();
                while (true) {
                    //读取数据（阻塞）
                    int read = inputStream.read(bytes);
                    if (read != -1) {
                        System.out.println(new String(bytes, 0, read));
                    } else {
                        break;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    System.out.println("socket关闭");
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

**4.2 测试IO**

1）使用telnet连接服务端（如果提示telnet不是内部命令，则如图所示，启用telnet）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 2][]

2）然后在cmd里面连接

![20200613122834288.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 3][]

3）使用telnet发送消息：（使用telnet 发送消息 Ctrl + \]  进入输入send开始+消息，最后按enter 这样才会发送完整的一个消息，不然你输入一个字符就会返回一个字符）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 4][]

**4.3 NIO服务端代码介绍**

package com.cxb.NIO;
    
    import java.io.IOException;
    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;
    
    /**
     * NIO服务端
     */
    public class NIOServer {
    	// 通道管理器
    	private Selector selector;
    
    	/**
    	 * 获得一个ServerSocket通道，并对该通道做一些初始化的工作
    	 * 
    	 * @param port
    	 *            绑定的端口号
    	 * @throws IOException
    	 */
    	public void initServer(int port) throws IOException {
    		// 获得一个ServerSocket通道
    		ServerSocketChannel serverChannel = ServerSocketChannel.open();
    		// 设置通道为非阻塞
    		serverChannel.configureBlocking(false);
    		// 将该通道对应的ServerSocket绑定到port端口
    		serverChannel.socket().bind(new InetSocketAddress(port));
    		// 获得一个通道管理器
    		this.selector = Selector.open();
    		// 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后，
    		// 当该事件到达时，selector.select()会返回，如果该事件没到达selector.select()会一直阻塞。
    		serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    	}
    
    	/**
    	 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
    	 * 
    	 * @throws IOException
    	 */
    	public void listen() throws IOException {
    		System.out.println("服务端启动成功！");
    		// 轮询访问selector
    		while (true) {
    			// 当注册的事件到达时，方法返回；否则,该方法会一直阻塞
    			selector.select();
    			// 获得selector中选中的项的迭代器，选中的项为注册的事件
    			Iterator<?> ite = this.selector.selectedKeys().iterator();
    			while (ite.hasNext()) {
    				SelectionKey key = (SelectionKey) ite.next();
    				// 删除已选的key,以防重复处理
    				ite.remove();
    
    				handler(key);
    			}
    		}
    	}
    
    	/**
    	 * 处理请求
    	 * 
    	 * @param key
    	 * @throws IOException
    	 */
    	public void handler(SelectionKey key) throws IOException {
    		
    		// 客户端请求连接事件
    		if (key.isAcceptable()) {
    			handlerAccept(key);
    			// 获得了可读的事件
    		} else if (key.isReadable()) {
    			handelerRead(key);
    		}
    	}
    
    	/**
    	 * 处理连接请求
    	 * 
    	 * @param key
    	 * @throws IOException
    	 */
    	public void handlerAccept(SelectionKey key) throws IOException {
    		ServerSocketChannel server = (ServerSocketChannel) key.channel();
    		// 获得和客户端连接的通道
    		SocketChannel channel = server.accept();
    		// 设置成非阻塞
    		channel.configureBlocking(false);
    
    		// 在这里可以给客户端发送信息哦
    		System.out.println("新的客户端连接");
    		// 在和客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限。
    		channel.register(this.selector, SelectionKey.OP_READ);
    	}
    
    	/**
    	 * 处理读的事件
    	 * 
    	 * @param key
    	 * @throws IOException
    	 */
    	public void handelerRead(SelectionKey key) throws IOException {
    		// 服务器可读取消息:得到事件发生的Socket通道
    		SocketChannel channel = (SocketChannel) key.channel();
    		// 创建读取的缓冲区
    		ByteBuffer buffer = ByteBuffer.allocate(1024);
    		int read = channel.read(buffer);
    		if(read > 0){
    			byte[] data = buffer.array();
    			String msg = new String(data).trim();
    			System.out.println("服务端收到信息：" + msg);
    			
    			//回写数据
    			ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
    			channel.write(outBuffer);// 将消息回送给客户端
    		}else{
    			System.out.println("客户端关闭");
    			key.cancel();
    		}
    	}
    
    	/**
    	 * 启动服务端测试
    	 * 
    	 * @throws IOException
    	 */
    	public static void main(String[] args) throws IOException {
    		NIOServer server = new NIOServer();
    		server.initServer(8002);
    		server.listen();
    	}
    
    }

**4.4 测试NIO**

1）连接服务端

![20200613123916560.png][]

2）发送消息，连接两个实例的客户端，服务端都能接收到消息。

![20200613123944653.png][]

**4.6 总结**

1）传统IO特点  
      阻塞点  
      server.accept();  
      inputStream.read(bytes);

2）单线程情况下只能有一个客户端  
3）用线程池可以有多个客户端连接，但是非常消耗性能

4）NIO的特点

5）ServerSocketChannel    ServerSocket

SocketChannel        Socket

Selector

SelectionKey

6）NIO的一些疑问

1、客户端关闭的时候会抛出异常，死循环  
      解决方案

int read = channel.read(buffer);
            if(read > 0){
                byte[] data = buffer.array();
                String msg = new String(data).trim();
                System.out.println("服务端收到信息：" + msg);
                
                //回写数据
                ByteBuffer outBuffer = ByteBuffer.wrap("好的".getBytes());
                channel.write(outBuffer);// 将消息回送给客户端
            }else{
                System.out.println("客户端关闭");
                key.cancel();
            }

2、selector.select();阻塞，那为什么说nio是非阻塞的IO？

selector.select()  
    selector.select(1000);    不阻塞  
    selector.wakeup();         也可以唤醒selector  
    selector.selectNow();     也可以立马返还

3、SelectionKey.OP\_WRITE是代表什么意思

OP\_WRITE表示底层缓冲区是否有空间，是则响应返还true

[代码下载][Link 1]

[20200613112418142.png]: https://img-blog.csdnimg.cn/20200613112418142.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200613112807380.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200613112817204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020061312274762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[20200613122834288.png]: https://img-blog.csdnimg.cn/20200613122834288.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200613122912390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200613122920488.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMzcxNzY2,size_16,color_FFFFFF,t_70
[20200613123916560.png]: https://img-blog.csdnimg.cn/20200613123916560.png
[20200613123944653.png]: https://img-blog.csdnimg.cn/20200613123944653.png
[Link 1]: https://github.com/ChenXbFrank/nettyLearnCode