Netty入门之网络编程

前两篇文章简单讲解了Netty入门基础篇的相关基本概念:

以上两篇内容主要讲了NIO的三大组件、ByteBuffer、文件编程等，需要了解像详情的请移步查看。

步入正题: 说到网络编程不得不提网络编程中的阻塞概念、以及非阻塞概念，相信大家都有所耳闻，接下来逐步为大家解析其中的主要概念:

阻塞和非阻塞

阻塞:

阻塞模式下，相关的方法会导致线程暂停，不会继续运行。
例如:

ServerSocketChannel.accept()会在没有连接建立时让线程暂停
SocketChannel.read()会在没有数据可读时让线程暂停

代码演示-阻塞模式

Server端

public static void main(String[] args) throws IOException {
        // 使用NIO来理解阻塞模式

        ByteBuffer buffer = ByteBuffer.allocate(16);

        // 创建服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();

        // 绑定端口
        ssc.bind(new InetSocketAddress(8080));

        // 连接集合
        List<SocketChannel> channels = new ArrayList<>();
        while (true){
            // accept 建立与客户端的连接 SocketChannel 用来与客户端进行通信
            log.debug("connecting......");
            SocketChannel sc = ssc.accept(); // 阻塞方法 线程停止运行
            log.debug("connected......{}",sc);
            channels.add(sc);
            for (SocketChannel channel : channels) {
                // 接收客户端发送的数据
                log.debug("before read...{}",channel);
                channel.read(buffer);  // 阻塞方法 线程停止运行
                buffer.flip();
                debugRead(buffer);
                buffer.clear();
                log.debug("after read...{}",channel);
            }
        }

    }

Client端

  public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost",8080));

        System.out.println("waiting.......");
    }

阻塞的表现其实就是线程暂停了，暂停期间不会占用CPU，但相当于线程处于闲置状态。

单线程情况下，阻塞方法之间相互影响，几乎不能正常工作，需要多线程支持
多线程下，有新的问题，主要体现在以下几个方面

32位JVM一个线程320k，64位JVM一个线程1024k，如果连接数过多，必然导致OOM，并且线程太多，反而因为频繁上下文切换导致性能降低
可以采用线程池技术，来减少线程数和频繁的上下文切换，但是治标不治本，如果有很多连接建立，但长时间inactive，会阻塞线程池中的所有线程，因此不适合长连接，只适合短连接。

非阻塞

非阻塞模式下，相关方法都不会让线程停止

在ServerSocketChannel.accept()在没有建立时，会返回null，继续运行。
SocketChannel.read()在没有数据可读时，会返回0，但线程不阻塞，可以去执其行它的SocketChannel的read或是去执行ServerSocketChannel.accept
写数据时，线程只是等待数据写入Channel即可，无需等Channel通过网络把数据发送出去

但非阻塞模式下，即使没有建立连接和可读取数据时，线程仍然在不断运行，白白浪费CPU
数据复制过程中，线程实际还是阻塞的(AIO改进的地方)

代码演示-非阻塞模式

Server端

 public static void main(String[] args) throws IOException {
        // 使用NIO来理解阻塞模式

        ByteBuffer buffer = ByteBuffer.allocate(16);

        // 创建服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();

        ssc.configureBlocking(false); // 非阻塞模式
        // 绑定端口
        ssc.bind(new InetSocketAddress(8080));

        // 连接集合
        List<SocketChannel> channels = new ArrayList<>();
        while (true){
            // accept 建立与客户端的连接 SocketChannel 用来与客户端进行通信
            SocketChannel sc = ssc.accept(); // 非阻塞，线程会继续运行，如果没有连接建立返回的是null
            if (sc != null){
                log.debug("connected......{}",sc);
                sc.configureBlocking(false);
                channels.add(sc);
            }
            for (SocketChannel channel : channels) {
                // 接收客户端发送的数据
                int read = channel.read(buffer);// 非阻塞方法 线程会继续运行 如果没有读到数据会返回0
                if (read > 0){
                    buffer.flip();
                    debugRead(buffer);
                    buffer.clear();
                    log.debug("after read...{}",channel);
                }
            }
        }

    }

Client端

public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost",8080));

        System.out.println("waiting.......");
    }

}

以上就是单线程情况下，阻塞模式和非阻塞模式的两种案例，相信仔细的你已经发现:
阻塞某个方法的执行都会影响其他方法的执行，你accept了就不能read 反之亦是如此。非阻塞模式即使在你没有连接请求和数据发送的时候它也在那里进行空转，大大浪费了CPU资源，

为此我们使用之前讲到的selector来进行优化,也引出了 多路复用

多路复用

单线程可以配合Selector完成对多个Channel可读事件的监控，这称之为多路复用

多路复用仅针对网络IO。普通文件IO没法利用多路复用
如果不使用Selector的非阻塞模式，线程大部分时间都在做无用功，而Selector能够保

有可连接事件时才去连接
有可读事件才去读取
有可写时间才去写入
限于网络的传输能力，Channel未必时时可写，一旦Channel可写，会触发Selector的可写事件。

Selector

上述文字里有一只提到事件,细心的小伙伴已经发现了。

主要的事件类型有:

accept – 会在连接请求时触发 (客户端连接成功时触发)
connect – 是客户端，连接建立后触发 (服务端成功接收连接时触发)
read – 可读事件 (数据可读入时触发，有因为接收能力弱，数据暂不能读入的情况)
write – 可写事件数据可写出时触发，有因为发送能力弱，数据暂不能写出的情况

ServerSocketChannel 主要关注的是accept事件

interestOps(SelectionKey.OP_ACCEPT)

SocketChannel 主要关注的是read,write事件

Selector.select() 方法没有事件就阻塞有事件恢复在事件未处理时它不会阻塞事件发生后要么处理要么取消不能置之不理

selectedKeys内部包含了所有发生的事件,但是它只会加事件，不会自动删除事件的key，所以要有 iterator.remove(); // 切记要删除否则空指针

demo

public class Server {
    public static void main(String[] args) throws IOException {
        // 创建selector 管理多个channel
        Selector selector = Selector.open();

//        ByteBuffer buffer = ByteBuffer.allocate(16);
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false); // 非阻塞模式
        // 建立selector和channel之间的联系
        // SelectionKey 就是事件发生后 通过它可以知道哪个channel发生的事件
        SelectionKey sscKey = ssc.register(selector, 0, null);
        sscKey.interestOps(SelectionKey.OP_ACCEPT);
        log.debug("register key:{}",sscKey);
        ssc.bind(new InetSocketAddress(8080));
        while (true){
            // select 方法 没有事件就阻塞  有事件恢复 在事件未处理时 它不会阻塞  事件发生后  要么处理 要么取消 不能置之不理
            selector.select();
            // 4. 处理事件  selectedKeys内部包含了所有发生的事件
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove(); // 切记要删除  否则空指针
                log.debug("key:{}",key);
                // 5. 区分事件类型
                if (key.isAcceptable()) {  // accept事件
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel sc = channel.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey = sc.register(selector, 0, null);
                    scKey.interestOps(SelectionKey.OP_READ); // 关注读事件
                    log.debug("{}",sc);
                    log.debug("scKey:{}",scKey);
//                key.cancel(); // 事件发生后  要么处理 要么取消 不能置之不理
                }
                else if (key.isReadable()){ // read事件
                    try {
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(16);
                        int read = channel.read(buffer); // 正常断开返回值是-1
                        if (read == -1){
                            key.cancel();
                        }else {
                            buffer.flip();
                            debugRead(buffer);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        key.cancel();// 客户端断开（无论是正常断开还是异常 都会产生一个read事件）  从selector keys的集合中真正删除
                    }
                }

            }
        }

    }
}

需要注意代码中注释的地方以上的demo案例已经完全展示了selector的主要用法以及注意事项，简单总结一下
如图:

使用Selector的好处:

一个线程配合selector就可以监控多个channel的事件，事件发生线程才去处理。避免非阻塞模式下所做的无用功
让线程能够被充分利用
节约了线程的数量
减少了线程的上下文切换

Selector的主要方法：

创建

Selector selector = Selector.open();

绑定(注册)Channel事件:
只有注册了的事件selector才会关心

channel.configureBlocking(false);
SelectorKey key = channel.register(selector,0,null) //具体后面解释

channel 必须工作在非阻塞模式

FileChannel 没有非阻塞模式，因此不能配合 selector 一起使用

监听channel事件: 可以通过下面三种方法来监听是否有事件的发生，方法的返回值代表有多少channel发生了事件

方法一: 阻塞直至绑定事件发生

int count = selector.select();

方法二: 阻塞直至绑定事件发生，或是超时（时间单位ms）

int count = selector.select(long timeout);

方法三: 不会阻塞，也就是不管有没有事件，立刻返回，自己根据返回值检查是否有事件

int count = selector.selectNow();

💡 select 何时不阻塞

事件发生时

客户端发起连接请求，会触发 accept 事件
客户端发送数据过来，客户端正常、异常关闭时，都会触发 read 事件，另外如果发送的数据大于 buffer 缓冲区，会触发多次读取事件
channel 可写，会触发 write 事件
在 linux 下 nio bug 发生时

调用 selector.wakeup()
调用 selector.close()
selector 所在线程 interrupt

💡 为何要 iter.remove()

因为 select 在事件发生后，就会将相关的 key 放入 selectedKeys 集合，但不会在处理完后从 selectedKeys 集合中移除，需要我们自己编码删除。例如

第一次触发了 ssckey 上的 accept 事件，没有移除 ssckey

第二次触发了 sckey 上的 read 事件，但这时 selectedKeys 中还有上次的 ssckey ，在处理时因为没有真正的 serverSocket 连上了，就会导致空指针异常

💡cancel 的作用