nio、bio区别，应运场景

bio阻塞i/o

a.面向流的,InputStream(),OuputStream字节输入流，字节输出流,Reader，Writer字符输入流，字符输出流
b.阻塞的IO,比如Socket，它的底层用的BIO机制，accept()、connect()、write()调用时会产生阻塞。阻塞模型的局限性：不可能应对高并发、搞访问量的场景

总结：BIO方式适用于连接数目比较小并且一次发送大量数据的场景，这种方式对服务器资源要求比较高，并发局限于应用中

很简单转换成图型说明就是web浏览器发一个请求过来,web服务器就要new 一个线程来处理这个请求,这是传统的请求处理模型,这也就引来一个很大的问题,当请求越多,服务器端的启用线程也要越多,我们都知道linux(window)的文件句柄数有是限的,默认是1024,当然可以修改,上限好像是65536 ,(一个柄也相当于一个socket也相当于一个thread,linux查看文件句柄Unlimit -a) 其实在实际当中只要并发到1000上下响应请求就会很慢了,所以这种模型是有问题的,这种也就是同步阻塞IO编程（JAVA BIO）


以下是简单的bio例子：

Server端代码：

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

/**
 *
 * @author
 * @date   2019-02-27
 */
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket socket = new ServerSocket();
        socket.bind(new InetSocketAddress(9999));
        while(true) {
            Socket sc = socket.accept();
            new Thread(new Accept(sc)).start();
        }
    }
}
class Accept implements Runnable{
    private Socket sc = null;
    public Accept(Socket sc) {
        sc = this.sc;
    }
    @Override
    public void run() {
        System.out.println("提供服务的线程id是："+Thread.currentThread().getId());
    }

}

Clinet端代码

/**
 *
 * @author
 * @date   2019-02-27
 */
public class Client {
    public static void main(String[] args) throws IOException {
        Socket sc = new Socket();
        sc.connect(new InetSocketAddress( "127.0.0.1",9999),0);
        while(true) {

        }
    }
}

启动server端，然后多次启动client端，打印结果如下


nio非阻塞i/o

a.面向缓冲区的（Buffer）,NIO是通过缓冲区去操作数据的，可以用缓冲区灵活操作数据,此外，NIO是面向通道的（Channel），在通道上，即可以读数据，也可以写数据

b.NIO是非阻塞的IO，可以利用NIO处理高并发和高访问量的场景，NIO适合处理连接数目特别多，但是连接比较短（轻操作）的场景，Jetty，Mina，ZooKeeper等都是基于java的nio实现。服务器需要支持超大量的长时间连接。比如10000个连接以上，并且每个客户端并不会频繁地发送太多数据

首先，引入nio的3个相关概念：
1> Buffer 缓冲区
难用的buffer是一个抽象的对象,下面还有ByteBuffer,IntBuffer,LongBuffer等子类,相比老的IO将数据直接读/写到Stream对象,NIO是将所有数据都用到缓冲区处理,它本质上是一个数组,提供了位置,容量,上限等操作方法,还是直接看代码代码来得直接
2>Channel 通道
如自来水管一样,支持网络数据从Channel中读写,通道写流最大不同是通道是双向的,而流是一个方向上移动(InputStream/OutputStream),通道可用于读/写或读写同时进行,它还可以和下面要讲的selector结合起来,有多种状态位,方便selector去识别. 通道分两类，一：网络读写（selectableChannel),另一类是文件操作(FileChannel),我们常用的是上面例子中的网络读写!

3>Selector 多路复用选择器
它是神一样存在的东西,多路复用选择器提供选择已经就绪的任务的能力,也就是selector会不断轮询注册在其上的通道(Channel),如果某个通道发生了读写操作,这个通道处于就绪状态,会被selector轮询出来,然后通过selectionKey可以取得就绪的Channel集合,从而进行后续的IO操作.
一个多路复用器(Selector)可以负责成千上万个Channel,没有上限,这也是JDK使用epoll代替了传统的selector实现,获得连接句柄没有限制.这也意味着我们只要一个线程负责selector的轮询,就可以接入成千上万个客户端,这是JDK,NIO库的巨大进步.



以下是server端代码：

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;
import java.util.Set;

public class NioServer {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(6666));

        Selector selector = Selector.open();
        ssc.register(selector,SelectionKey.OP_ACCEPT);
        while(true) {
            selector.select();
            Set<SelectionKey> set = selector.selectedKeys();
            //获取事件结合的迭代器
            Iterator<SelectionKey> iter = set.iterator();
            while(iter.hasNext()) {
                SelectionKey sk = iter.next();
                if(sk.isAcceptable()) {
                    //证明有客户端请求建立回迁连接
                    ServerSocketChannel ss = (ServerSocketChannel)sk.channel();
                    //创建会话对象
                    SocketChannel sc = null;
                    while(sc==null) {
                        sc = ss.accept();
                    }
                    //设置为非阻塞模式
                    sc.configureBlocking(false);
                    //输出为客户端提供服务的线程ID
                    System.out.println("有客户端连入，负责提供服务的"
                            + "线程id:"+Thread.currentThread().getId());
                    //为sc注册read事件和write事件
                    sc.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
                }
                if(sk.isReadable()) {
                    //获取SocketChannel对象
                    SocketChannel sc = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.allocate(10);
                    sc.read(buf);
                    System.out.println("服务器端独到的内容："
                            +new String(buf.array()));
                    System.out.println("负责处理读请求的线程ID："
                            +Thread.currentThread().getId());
                    sc.register(selector,sk.interestOps()&~SelectionKey.OP_READ);
                }
                if(sk.isWritable()) {
                    //获取SocketChannel对象
                    SocketChannel sc = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.wrap("over".getBytes());
                    sc.write(buf);
                    System.out.println("负责处理写请求的线程ID:"
                            +Thread.currentThread().getId());
                    sc.register(selector,sk.interestOps()&~SelectionKey.OP_WRITE);
                }
                //删除该事件，目的：为了防止同一个事件被处理多次
                iter.remove();
            }

        }
    }
}

以下是client端代码

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class NIOClient {
    public static void main(String[] args) throws Exception {
        SocketChannel sc = SocketChannel.open();
        sc.configureBlocking(false);
        sc.connect(new InetSocketAddress("127.0.0.1", 6666));
        while(!sc.isConnected()) {
            sc.finishConnect();
        }
        ByteBuffer buf = ByteBuffer.wrap("helloworld".getBytes());
        sc.write(buf);
        ByteBuffer readBuf = ByteBuffer.allocate(9);
        Thread.sleep(1000);
        sc.read(readBuf);
        System.out.println("客户端读取到服务器发送过来的内容："
                +new String(readBuf.array()));
        while(true) {

        }
    }
}

这里补充一点aio，这个比NIO先进的技术,最终实现了
netty
这是神一样存在的java nio框架, 这个偏底层的东西,可能你接触较少却又无处不在,比如:

在业界有一篇无法超越的netty入门文章,我也没这个能力超越,只能双手奉上,你们好好研读,必然学有所成!
http://ifeve.com/netty5-user-guide/

本文部分参考于：
https://www.cnblogs.com/barrywxx/p/8430790.html