开发必学，io&nio

作为一个程序开发人员，不可避免的要与io打交道，通常我们也都会在简历栏目上写上熟悉or了解io，那么你是否真的了解io与nio的区别呢？【划重点：面试官常问点】

首先，在详细描述io与nio的区别之前我们要先意识到

所有的系统I/O都分为两个阶段：等待就绪和操作。
并且等待就绪的阻塞是不使用CPU的，是在“空等”；

而真正的读写操作的阻塞是使用CPU的，真正在"干活"，也意味着会消耗cpu资源。

为了让大家有个更加直观的感受，这里先抛出基于io和基于nio实现的例子。

io实现

package test;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class IOServer {
    public static void main(String[] args) throws Exception {

        init();
    }

    private static void init() throws IOException {
        ServerSocket serverSocket = new ServerSocket(8000);
        new Thread(() -> {
            while (true) {
                // 阻塞点，获取新的连接
                Socket socket = null;
                try {
                    socket = serverSocket.accept();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                // 创建线程点，给每一个新的连接都创建一个线程
                Socket finalSocket = socket;
                new Thread(() -> {
                    int len;
                    byte[] data = new byte[1024];
                    InputStream inputStream = null;
                    try {
                        inputStream = finalSocket.getInputStream();
                        // 面向流，按字节流方式读取数据
                        while ((len = inputStream.read(data)) != -1) {
                            System.out.println(new String(data, 0, len));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }).start();
            }
        }).start();
    }
}

可以从上面的例子看出Server 端首先创建了一个serverSocket来监听 8000 端口，然后创建一个线程，线程里面死循环不断调用阻塞方法 serversocket.accept();获取新的客户端连接，当获取到新的连接之后，给每条连接创建一个新的线程，这个线程负责从该连接中读取数据然后读取数据是以字节流的方式。

这里的弊端是极其明显的，如

• 线程资源受限：上面每个客户端都会构建一个线程去做读取操作，而线程是操作系统中非常宝贵的资源，同一时刻有大量的线程处于阻塞状态是非常严重的资源浪费，操作系统耗不起。

• 线程切换效率低下：线程爆炸之后带来的副作用便是操作系统频繁进行线程切换，应用性能急剧下降。

nio实现

package test;

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.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;

public class NIOServer {
    public static void main(String[] args) throws IOException {
        init();
    }

    private static void init() throws IOException {
        
        // 构建Selector
        Selector serverSelector = Selector.open();
        Selector clientSelector = Selector.open();
        
        // 开启一个线程处理客户端的连接
        new Thread(() -> {
            try {
                // 此处对应IO编程中服务端启动
                ServerSocketChannel listenerChannel = ServerSocketChannel.open();
                listenerChannel.socket().bind(new InetSocketAddress(8000));
                listenerChannel.configureBlocking(false);
                listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);

                while (true) {
                    // 使用Selector来监测是否有新的连接，这里的1指的是阻塞的时间为 1ms
                    if (serverSelector.select(1) > 0) {
                        Set<SelectionKey> set = serverSelector.selectedKeys();
                        Iterator<SelectionKey> keyIterator = set.iterator();
                        
                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();

                            if (key.isAcceptable()) {
                                try {
                                    // 同io不同的地方，每来一个新连接，没有再创建一个线程，而是直接注册到clientSelector
                                    SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
                                    clientChannel.configureBlocking(false);
                                    clientChannel.register(clientSelector, SelectionKey.OP_READ);
                                } finally {
                                    keyIterator.remove();
                                }
                            }

                        }
                    }
                }
            } catch (IOException ignored) {
            }

        }).start();

        // 开启一个线程处理多个客户端线程的数据读取
        new Thread(() -> {
            try {
                while (true) {
                    // 轮询是否有哪些连接有数据可读，这里的1指的是阻塞的时间为 1ms
                    if (clientSelector.select(1) > 0) {
                        Set<SelectionKey> set = clientSelector.selectedKeys();
                        Iterator<SelectionKey> keyIterator = set.iterator();

                        while (keyIterator.hasNext()) {
                            SelectionKey key = keyIterator.next();

                            if (key.isReadable()) {
                                try {
                                    SocketChannel clientChannel = (SocketChannel) key.channel();
                                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                                    // 同io不同的地方，面向 Buffer
                                    clientChannel.read(byteBuffer);
                                    byteBuffer.flip();
                                    System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer)
                                            .toString());
                                } finally {
                                    keyIterator.remove();
                                    key.interestOps(SelectionKey.OP_READ);
                                }
                            }

                        }
                    }
                }
            } catch (IOException ignored) {
            }
        }).start();
    }
}

可以通过上面代码看出，

NIO 实现给出了两个线程，每个线程都绑定一个轮询器 selector ，如serverSelector负责轮询是否有新的连接，而clientSelector负责轮询判断客户端的连接是否有数据可读，和io实现的区别点有：

• 在服务端监测到新的连接之后，不会很sb的创建一个新的线程，而是直接将新连接绑定到clientSelector上，这样就不会消耗那么多线程资源了。

• clientSelector则会进行判断如果在某一时刻有多条连接有数据可读，那么通过 clientSelector.select(1)方法可以轮询出来，进而处理客户端数据。

• 数据的读写面向 Buffer。

因此我们可以得出结论：io是面向流的阻塞io，而nio是面向缓冲区的非阻塞io

所谓的阻塞io和非阻塞io：

• 阻塞io意味着当线程调用read（）或write（）时，该线程将会被阻塞，直到有一些数据要读取，或者数据被完全写入。而在此期间，被阻塞的线程将无法执行任何其他操作。
• 非阻塞io指的是允许线程请求从通道读取数据，如果通道没有数据可以读取的时候，线程可以继续使用其他内容，而不是在数据可供读取之前保持阻塞状态。

所谓的面向流和面向缓冲区：

• 面向流的Java IO意味着可以从流中一次读取一个或多个字节，它们不会缓存在任何地方。此外，我们无法在流中的数据中前后移动。如果需要在从流中读取的数据中进行前后移动，则需要先将其缓存在缓冲区中。
• 面向缓冲区的Java-NIO则是将数据读入缓冲区。我们可以根据需要在缓冲区中进行前后移动。这可以让我们在处理过程中更具灵活性。但是，我们还需要检查缓冲区是否包含完整处理所需的所有数据。当然了，还需要确保在将更多数据读入缓冲区时，不会出现bug，比如覆盖了尚未处理的缓冲区中的数据。

---

系列博客可以关注公众号：