Java nio 阻塞与非阻塞模式

传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。

Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。因此， NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。

 一、使用nio来理解阻塞模式

1.创建服务器

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){
            //建立客户端连接
            log.debug("connecting...");
            SocketChannel sc=ssc.accept();//阻塞方法，线程停止运行
            log.debug("connected...{}",sc);
            channels.add(sc);
            for (SocketChannel s:channels) {
                log.debug("before read...{}",s);
                s.read(buffer);//阻塞方法，线程停止运行
                buffer.flip();
                ByteBufferUtil.debugRead(buffer);
                buffer.clear();
                log.debug("after read...{}",s);
            }
        }
    }

启动服务器后会打印日志connecting... 之后停止运行 因为建立链接是一个阻塞方法 

2.客户端

public static void main(String[] args) throws IOException {
        SocketChannel sc = SocketChannel.open();
        sc.connect(new InetSocketAddress("localhost",8080));
        sc.write(Charset.defaultCharset().encode("hello world"));
        System.out.println("waiting...");
    }

启动客户端后进行链接 服务器建立连接后继续向下运行  读取方法也是阻塞方法 如果链接没有写入数据也不会继续向下运行

那我们客户端没有进行写入操作 又来了一条链接这时我们的线程会在读取那进行堵塞 无法受理链接请求

或者我们读取数据后 客户端又写入了一条数据 这时我们的线程运行完成后会重新回到建立客户端链接 你这时需要调取读取方法 而线程停止在链接方法

 二、使用nio来理解非阻塞模式

1.创建服务器

我们可以通过ServerSocketChannel 的configureBlocking的方法将其设置为非阻塞模式

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){
            //建立客户端连接
            SocketChannel sc=ssc.accept();//非阻塞方法，线程还会继续运行 如果没有连接建立，sc为null
            if(sc!=null){
                log.debug("connected...{}",sc);
                sc.configureBlocking(false);//设置非阻塞模式
                channels.add(sc);
            }
            for (SocketChannel s:channels) {
                int read=s.read(buffer);//非阻塞方法，线程还会继续运行 如果没有数据可读，read返回0
                if (read>0){
                    buffer.flip();
                    ByteBufferUtil.debugRead(buffer);
                    buffer.clear();
                    log.debug("after read...{}",s);
                }
            }
        }
    }

设置为非阻塞模式后他的循环是一直循环的不会存在停止运行 这时我们可以通过他方法的返回值进行操作

 2.客户端不变

 这是我们可以通过端口号看到多个客户端进行链接是不受影响的

 ByteBufferUtil工具类

import java.nio.ByteBuffer;

import io.netty.util.internal.MathUtil;
import io.netty.util.internal.StringUtil;



public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(StringUtil.NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (MathUtil.isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        StringUtil.NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        StringUtil.NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(StringUtil.NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(StringUtil.NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }

三、使用selector,管理多个channel

从上面两个处理方式来看

阻塞模式在单线程的情况下有点傻

非阻塞模式又比较占用资源

所以我们这边需要使用selector来管理多个channel

 

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);//只关注accept事件 也可以通过创建时传参的方式指定 0表示不关注任何事件
        log.debug("sscKey:{}",sscKey);

        ssc.bind(new InetSocketAddress(8080));
        while (true){
            //select方法是阻塞的，没有事件发生，线程停止运行，有事件发生，线程才会运行
            //select 在事件未处理时，它不会阻塞，事件发生后要么处理，要么取消，不能置之不理
            selector.select();
            //处理事件,selectedKeys中包含了所有发生的事件
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
            while (iter.hasNext()){
                SelectionKey key = iter.next();
                log.debug("key:{}",key);
                //selected 会在发生事件后 向selectedKeys中添加事件 不会删除
                iter.remove();
                //区分事件类型
                if (key.isAcceptable()) {
                    ServerSocketChannel channel = (ServerSocketChannel) key.channel();
                    SocketChannel sc=channel.accept();
                    sc.configureBlocking(false);
                    SelectionKey scKey=sc.register(selector,0,null);
                    scKey.interestOps(SelectionKey.OP_READ);//只关注read事件
                    log.debug("sscKey:{}",scKey);
                    log.debug("{}",sc);
                }else if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    Integer sc=channel.read(buffer);
                    if (sc>0){
                        buffer.flip();
                        ByteBufferUtil.debugRead(buffer);
                        buffer.clear();
                    }
                }
            }
        }
    }

运行结果如下

 

 使用selector管理后只有发生事件时线程才会运行 没有事件发生时他就是阻塞的