BIO&NIO

BIO 阻塞IO

首先要明确的一点是NIO中非阻塞的实现是基于Selector的，所以如果不采用Selector，只采用channel和buffer，还是存在阻塞。

看一下BIO的Server

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8890));
        while(true){
            SocketChannel socketChannel=serverSocketChannel.accept(); // accept 阻塞
            BlockHandler handler=new BlockHandler(socketChannel);
            new Thread(handler).start();
        }
    }
}

类似于传统的java Socket编程，因为没有采用Selector，这里每有客户端过来请求连接的时候，服务器都会新建一个连接来管理。

public class BlockHandler implements  Runnable{

    private  SocketChannel socketChannel;

    public BlockHandler(SocketChannel socketChannel) {
        this.socketChannel=socketChannel;
    }

    @Override
    public void run() {
        ByteBuffer buffer=ByteBuffer.allocate(1024);
        int num;
        try {
            while((num=socketChannel.read(buffer))>0){   // 因为建立连接后就来到这里了，此时并不一定可读，故read阻塞等待数据
                buffer.flip();
                byte[] bytes=new byte[num];
                buffer.get(bytes);   // 将buffer中的字符给bytes
                String re=new String(buffer.array(),"UTF-8");
                System.out.println("收到请求"+re);
                ByteBuffer writeBuffer=ByteBuffer.wrap(("我已经收到你的请求，你的请求内容是"+re).getBytes());
                socketChannel.write(writeBuffer);   // 此处write也是阻塞操作，此时并不一定可以写，等待通道可写
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上边代码是服务端的实现，socketChannel.read(buffer)先将客户端通过channel传送过来的消息放入buffer，注意此时position的位置在最后边，我们要想从buffer中取出消息，就还需要首先flip一下，将position置为0。接着服务器读出并消息，服务器通过wrap将回应写入buffer，通过write写入channel发送给客户端。最后，清空服务器的buffer。

再来看一下BIO Client

public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel= SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1",8890));
        ByteBuffer buffer=ByteBuffer.wrap("123456678".getBytes());
        socketChannel.write(buffer);

        // 读取响应
        ByteBuffer readBuffer=ByteBuffer.allocate(1024);
        int num;
        // 从channel到buffer，从buffer到bytes
        if((num=socketChannel.read(readBuffer))>0){
            readBuffer.flip();
            byte[] re = new byte[num];   // 将buffer中的字符赋到re
            readBuffer.get(re);

            String result = new String(readBuffer.array(), "UTF-8");
            System.out.println("返回值: " + result);
        }
    }
}

过程跟server端的处理大致一样，就不过多赘述了。

NIO

非阻塞 IO 的核心在于使用一个 Selector 来管理多个channel，之后可以只用一个线程来轮询这个 Selector，看看上面是否有通道是准备好的，当通道准备好可读或可写，然后才去开始真正的读写，这样速度就很快了。我们就完全没有必要给每个通道都起一个线程。即不见兔子不撒鹰，只有通道说我好了，线程才会为它去工作。

Selector是对底层操作系统的抽象。

epoll 可以返回准备好的信道，O（1）

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel= ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress("127.0.0.1",8890));
        serverSocketChannel.configureBlocking(false);
        Selector selector=Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while(true){
            if(selector.select()==0) continue;
            Set<SelectionKey> readkeys=selector.selectedKeys();
            //使用完毕必须移除，selector不会自己移除处理过的已选择selectionkey
            //for(SelectionKey readKey:readkeys){
            Iterator<SelectionKey> iterator=readkeys.iterator();
            while(iterator.hasNext()){
                SelectionKey readKey=iterator.next();
                iterator.remove();
                if(readKey.isAcceptable()){
                    SocketChannel socketChannel=serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    // 为什么不对写感兴趣？  对读感兴趣的话，客户端不发消息过来是不会开线程给这个channel的，因此不会造成CPU资源的浪费；
                    //对写感兴趣的话，和可能会造成分配线程给这个channel，cpu空转等待写入数据
                    socketChannel.register(selector,SelectionKey.OP_READ);
                }
                else if(readKey.isReadable()){
                    // 实际情况中，可能有很多个通道都准备好了，这部分可以使用线程池
                    SocketChannel socketChannel = (SocketChannel) readKey.channel();
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    int num = socketChannel.read(readBuffer);
                    if(num>0){
                        System.out.println("收到数据：" +new String(readBuffer.array()));
                        ByteBuffer buffer = ByteBuffer.wrap("返回给客户端的数据...".getBytes());
                        // 注意这里就能写了已经
                        socketChannel.write(buffer);
                    }
                    else if(num==-1){
                        socketChannel.close();
                    }
                }
            }
        }
    }
}

注释写的比较清楚，不过多讲解