JavaIO演进之路

先提两大问题：

• 为什么要学Netty?

Spring5 底层用Netty

Spring Boot 不需要netty，它内部实现了web容器

Zookeeper 也是用的Netty

Dubbo 分布式服务框架 多协议支持(RPC) Netty

有可能成为Java架构师的你的筑基

• Netty能帮我们解决什么问题？

框架：简化开发一系列解决方案的集合，封装IO操作的框架

复杂业务场景中，没有说用一个单独IO API

IO + 多线程来解决问题 Netty是用来封装IO操作

本篇学习目标：

• 掌握Java中BIO、NIO、AIO之间的区别及应用场景。
• 透彻理解阻塞（Block）与非阻塞（Non-Block）区别。
• 透彻理解同步（Synchronization）和异步（Asynchronous）的区别。

本篇内容定位：

•  适合具有网络通信开发经验的人群。
• 适合具有1-3年Java Web开发经验的人群。

input和output：

input和output是相对于内存而言的，向内存中写入input，从内存中读出output

 阻塞要等待机器内存数据完全准备好，才能读向程序内存，非阻塞有动态轮询机制。

 阻塞和非阻塞是一种读取数据的策略，非阻塞实现了多路复用

 数据先进入缓冲区，然后轮询完成

同步和异步：

在处理数据的时候，在同一时间点，能做多个处理：异步，在同一时间只能做一个处理：同步。

阻塞（Block）和非阻塞（Non-Block）

阻塞：往往需要等待缓冲区中的数据准备好过后才处理其他事情，否则一直等待在那里。

非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接返回。

 阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候。

IO（BIO）、NIO与AIO对比：

 IO（BIO） Block IO  同步阻塞IO

NIO  Non-Block IO 同步非阻塞IO （可以用线程池实现异步）

AIO（NIO2） Async IO 异步非阻塞IO （事件驱动，回调）

 改进目的：提升IO操作的性能、IO框架出现

代码案例

BIO服务端：

/**
 * @ClassName BIOServer
 * @Author 周聪
 * @Date 2021/2/1 21:50
 * @Version 1.0
 * @Description BIO服务端
 */
public class BIOServer {

    /**
     * 服务的网络IO模型的封装对象
     */
    ServerSocket serverSocket;

    /**
     * 服务器
     *
     * @param port
     */
    public BIOServer(int port) {
        try {
//            Tomcat 默认端口8080
//            只要是Java写的底层都是ServerSocket
            serverSocket = new ServerSocket(port);
            System.out.println("BIO服务已启动，监听端口是：" + port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        new BIOServer(8080).listen();
    }

    /**
     * 开始监听，并处理逻辑
     *
     * @throws IOException
     */
    public void listen() throws IOException {
//        循环监听
        while (true) {
//            等待客户端连接，阻塞方法,只有客户端把数据发过来的时候才会动，否则一直等,程序不会进行下去
//            Socket数据发送者在服务端的引用
            Socket client = serverSocket.accept();
            System.out.println(client.getPort());
//            对方发数据给我了，读Input
            InputStream is = client.getInputStream();
//            JVM内存
//            网络客户端把数据发送到网卡，机器所得到的数据读到了JVM内存中
            byte[] buff = new byte[1024];
            int len = is.read(buff);
            if (len > 0) {
                String msg = new String(buff, 0, len);
                System.out.println("收到" + msg);
            }

        }
    }
}

客户端（NIO和BIO都可用）

/**
 * @ClassName BIOClient
 * @Author 周聪
 * @Date 2021/2/1 21:43
 * @Version 1.0
 * @Description BIO和NIO的客户端
 */
public class BIOClient {
//    FileOutputStream、FileInputStream 这里不拿磁盘操作案例，大家都很熟悉

    public static void main(String[] args) throws IOException {
//        要和谁进行通信，服务器IP、服务器的端口
//      一台机器的端口号是有限的
        Socket client = new Socket("localhost", 8080);
//        输出 不管是客户端还是服务端，都有可能write和read
        OutputStream os = client.getOutputStream();
//        生成一个随机的ID
        String name = UUID.randomUUID().toString();
        System.out.println("客户端发送数据：" + name);
        os.write(name.getBytes());
        os.close();
        client.close();
    }
}

NIO服务端

/**
 * @ClassName NIOServerDemo
 * @Author 周聪
 * @Date 2021/2/1 22:27
 * @Version 1.0
 * @Description NIO服务端 NIO的操作过于繁琐,于是才有了Netty
 * Netty就是对这一系列非常繁琐的操作进行了封装.
 */
public class NIOServerDemo {

    private int port = 8080;
    //    准备两个东西
    /**
     * 轮询器 Selector 大堂经理
     */
    private Selector selector;

    /**
     * 缓冲区 Buffer  等候区
     */
    private ByteBuffer buffer = ByteBuffer.allocate(1024);

    public NIOServerDemo(int port) {
//        初始化大堂经理，开门营业
        try {
            this.port = port;
            ServerSocketChannel server = ServerSocketChannel.open();
//            我得告诉地址，接客 IP/Port
            server.bind(new InetSocketAddress(this.port));
//            BIO 升级版本 NIO ,为了兼容BIO ，NIO模型默认是采用阻塞式
            server.configureBlocking(false);
//            大堂经理准备就绪，接客
            selector = Selector.open();
//            在门口端牌子，正在营业
            server.register(selector, SelectionKey.OP_ACCEPT);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new NIOServerDemo(8080).listen();
    }

    public void listen() {
        System.out.println("listen on " + this.port + ".");
//        轮询主线程
        try {
            while (true) {
                System.out.println("listen on " + this.port + ".");
//                大堂经理再叫号
                selector.select();
//                每次都拿到所以的号子
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
//                不断地迭代，就叫轮询
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
//                同步体现在这里，因为每次只能拿一个key，每次只能处理一种状态
                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove();
//                    每一个key代表一种状态
//                    每一个号对应一个业务，这里体现为 数据就绪，数据可读，数据可写等待...
                    process(key);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 具体办业务的方法，坐班柜员
     * 每一次轮询就是调用一次process方法，而每次调用只能干一件事
     * 在同一时间点，只能干一件事
     *
     * @param key
     */
    private void process(SelectionKey key) {

        try {
//        针对每一种状态给一个反应
            if (key.isAcceptable()) {
                ServerSocketChannel server = (ServerSocketChannel) key.channel();
//                这个方法体现非阻塞，不管你数据有没有准备好
//                你给我一个状态和反馈
                SocketChannel channel = server.accept();
                channel.configureBlocking(false);
//                当数据准备就绪的时候，将状态改为可读
                key = channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
//                key.channel 从多路复用器中拿客户端的引用
                SocketChannel channel = (SocketChannel) key.channel();
                int len = channel.read(buffer);
                if (len > 0) {
                    buffer.flip();
                    String content = new String(buffer.array(), 0, len);
                    channel.register(selector, SelectionKey.OP_WRITE);
//                    在key上携带一个附件，一会再写出去
                    key.attach(content);
                    System.out.println("读取内容：" + content);
                }
            } else if (key.isWritable()) {
                SocketChannel channel = (SocketChannel) key.channel();
                String content = (String) key.attachment();
                channel.write(ByteBuffer.wrap(("输出：" + content).getBytes()));
                channel.close();
            }


        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

AIO服务端

/**
 * @ClassName AIOServer
 * @Author 周聪
 * @Date 2021/2/1 23:21
 * @Version 1.0
 * @Description AIO服务端
 */
public class AIOServer {

    private final int port;

    public AIOServer(int port) {
        this.port = port;
        listen();
    }

    public static void main(String[] args) {
        int port = 8000;
        new AIOServer(port);
    }

    private void listen() {
        try {
            ExecutorService executorService = Executors.newCachedThreadPool();
            AsynchronousChannelGroup threadPool = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);
//            开门营业
//            工作线程,用来侦听回调,事件响应的时候需要回调
            final AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(threadPool);
            server.bind(new InetSocketAddress(port));
            System.out.println("服务已启动,监听端口: " + port);

//            准备接受数据
            server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {

                final ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

                /**
                 * 回调有两个状态:成功
                 * 实现completed方法来回调 由操作系统来触发
                 * @param result
                 * @param attachment
                 */
                @Override
                public void completed(AsynchronousSocketChannel result, Object attachment) {
                    System.out.println("IO操作成功,开始获取数据");
                    try {
                        byteBuffer.clear();
                        result.read(byteBuffer).get();
                        byteBuffer.flip();
                        result.write(byteBuffer);
                        byteBuffer.flip();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        try {
                            result.close();
                            server.accept(null, this);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("操作完成");
                }

                /**
                 * 回调有两个状态:失败
                 * @param exc
                 * @param attachment
                 */
                @Override
                public void failed(Throwable exc, Object attachment) {
                    System.out.println("IO操作失败: " + exc.getStackTrace());
                }

            });

            try {
                Thread.sleep(Integer.MAX_VALUE);
            } catch (Exception e) {
                e.printStackTrace();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

AIO客户端

/**
 * @ClassName AIOClient
 * @Author 周聪
 * @Date 2021/2/1 23:39
 * @Version 1.0
 * @Description AIO客户端
 */
public class AIOClient {

    private final AsynchronousSocketChannel clientChannel;

    public AIOClient() throws Exception {
        clientChannel = AsynchronousSocketChannel.open();
    }

    public static void main(String[] args) throws Exception {
        new AIOClient().connect("localhost", 8000);
    }

    public void connect(String host, int port) throws Exception {
        clientChannel.connect(new InetSocketAddress(host, port), null, new CompletionHandler<Void, Object>() {
            /**
             * 回调成功状态的方法
             * @param result
             * @param attachment
             */
            @Override
            public void completed(Void result, Object attachment) {
                try {
                    clientChannel.write(ByteBuffer.wrap("这是一条测试数据".getBytes())).get();
                    System.out.println("已发送至服务器");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            /**
             * 回调失败状态的方法
             * @param exc
             * @param attachment
             */
            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        final ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        clientChannel.read(byteBuffer, null, new CompletionHandler<Integer, Object>() {
            /**
             * 回调成功状态的方法
             * @param result
             * @param attachment
             */
            @Override
            public void completed(Integer result, Object attachment) {
                System.out.println("IO操作完成:" + result);
                System.out.println("获取反馈结果:" + new String(byteBuffer.array()));
            }

            /**
             * 回调失败状态的方法
             * @param exc
             * @param attachment
             */
            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

总结（应用场景）

JDK1.4以前都是BIO，之后NIO出现，性能得到大幅提升，Netty默认用的NIO

JDK1.7   NIO  === > 出现NIO2（AIO） 操作系统的性能，决定的IO的性能（存在兼容问题），目前不是主流

所有的IO实现异步都很容易，加入线程就可以，线程过多会有问题（CPU会爆），Netty引入了反应堆（线程池+调度）的概念。而AIO提供异步不需要。

BIO/NIO/AIO  他们的底层都是TCP/IP协议

欢迎批评指正。 附：源码地址