Java NIO 必知必会（Example）

管道流：

Java NIO 管道是2个线程之间的单向数据连接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。

package base.nio.threaddemo;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.Pipe;

/**
 * @program: Lear-Java
 * @description: 
 * @author: Mr.Dai
 * @create: 2018-10-05 20:43
 **/
public class ThreadSend {

    private Pipe pipe;


    private void init() throws Exception {
        this.pipe = Pipe.open();
    }


    class SendInner1 extends Thread {

        @Override
        public void run() {
            // 单向流 发送数据
            try {
                Pipe.SinkChannel sink = pipe.sink();
                sink.configureBlocking(false);

                while (true) {
                    if (sink.isOpen()) {
                        sink.write(ByteBuffer.wrap("abcd".getBytes()));
                    }
                    Thread.sleep(1000);
                }
            } catch (InterruptedException | IOException e) {
                e.printStackTrace();
            }
        }
    }

    class ReverInner extends Thread {
        @Override
        public void run() {
            try {
                // 单向流 拿到数据
                Pipe.SourceChannel source = pipe.source();

                source.configureBlocking(false);

                while (true) {
                    if (source.isOpen()) {
                        ByteBuffer buffer = ByteBuffer.allocate(10);
                        buffer.clear();
                        source.read(buffer);
                        // 这里必须去掉 trim
                        if(new String(buffer.array()).trim().equals("")){
                            continue;
                        }
                        System.out.println(new String(buffer.array()).trim());
                    }
                    Thread.sleep(1000);
                }
            } catch (InterruptedException | IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        ThreadSend send = new ThreadSend();

        send.init();

        SendInner1 sendI = send.new SendInner1();

        ReverInner revI = send.new ReverInner();

        sendI.start();
        revI.start();
    }


}

套接字通道流

非阻塞模式

ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept() 方法会立刻返回，如果还没有新进来的连接，返回的将是null。 因此，需要检查返回的SocketChannel是否是null。如：

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();  
  
serverSocketChannel.socket().bind(new InetSocketAddress(9999));  
serverSocketChannel.configureBlocking(false);  
  
 6   while(true){  
    SocketChannel socketChannel =  
            serverSocketChannel.accept();  
  
    if(socketChannel != null){  
        //do something with socketChannel...  
    }  
}  

server：

package base.nio.chatdemo;


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;

/**
 * @program: Lear-Java
 * @description: Nio 聊天服务端
 * @author: Mr.Dai
 * @create: 2018-10-05 16:31
 **/
public class ChatServer {

    /**
     * 通道管理器
     */
    private Selector selector;

    private void initServer(int port) throws Exception{

        ServerSocketChannel serverChannel  = ServerSocketChannel.open();

        serverChannel .socket().bind(new InetSocketAddress(port));
        // 配置非阻塞
        serverChannel .configureBlocking(false);


        this.selector=Selector.open();

        /**
         * 将通道管理器和该通道绑定，并为该通道注册selectionKey.OP_ACCEPT事件
         * 注册该事件后，当事件到达的时候，selector.select()会返回，
         * 如果事件没有到达selector.select()会一直阻塞
         * selector.selectNow() 立即返回 无论是否准备好 可能返回0
         */
        serverChannel .register(this.selector, SelectionKey.OP_ACCEPT);

    }

    /**
     * 采用轮训的方式监听selector上是否有需要处理的事件，如果有，进行处理
     */
    public void listen() throws Exception {
        System.out.println("start------------------->");
        while (true){
            // 在没有注册事件来到时 将会一直阻塞
            selector.select();
            Set<SelectionKey> set = selector.selectedKeys();
            Iterator<SelectionKey> iterator = set.iterator();

            while (iterator.hasNext()){
                SelectionKey key = iterator.next();
                // 移除当前阻塞队列
                iterator.remove();
                if(key.isAcceptable()){
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();

                    SocketChannel channel = server.accept();
                    channel.configureBlocking(false);
                    // 服务端发送数据
                    channel.write(ByteBuffer.wrap(new String("hello client").getBytes()));
                    // 在客户端连接成功之后，为了可以接收到客户端的信息，需要给通道设置读的权限
                    channel.register(this.selector,SelectionKey.OP_READ);

                }else if(key.isReadable()){
                    SocketChannel channel  = (SocketChannel) key.channel();

                    ByteBuffer buffer = ByteBuffer.allocate(10);
                    channel.read(buffer);

                    String msg = new String(buffer.array()).trim();

                    System.out.println("客户端发送过来的讯息："+msg);
                    // 在读取后 将柱塞队列数据 改变监听为Accept
                    ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
                    channel.write(outBuffer);
                }
                          }
        }

    }

    public static void main(String[] args)  throws Exception{
        ChatServer server = new ChatServer();
        server.initServer(8989);
        server.listen();
    }

}

clien：

package base.nio.chatdemo;

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

/**
 * @program: Lear-Java
 * @description: nio 聊天客户端
 * @author: Mr.Dai
 * @create: 2018-10-05 16:31
 **/
public class ChatClient {


    /**
     *  提供柱阻塞队列 管理器
     */
    private Selector selector;


    private void ininCliect(String ip,int port) throws Exception{

        SocketChannel channel  = SocketChannel.open();

        channel .connect(new InetSocketAddress(ip,port));

        this.selector=Selector.open();

        channel .configureBlocking(false);


        channel .register(this.selector, SelectionKey.OP_CONNECT);

    }

    public void listen() throws Exception {

        while (true){

            selector.select();

            Iterator<SelectionKey> ite  = selector.selectedKeys().iterator();

            while (ite.hasNext()){
                SelectionKey key = ite .next();
                ite .remove();
                if(key.isConnectable()){
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 是否准备好连接
                    if(channel.isConnectionPending()){
                        channel.finishConnect();
                    }
                    channel.configureBlocking(false);
                    // 向server 发送数据
                    channel.write(ByteBuffer.wrap("向server 发送数据".getBytes()));

                    channel.register(selector,SelectionKey.OP_READ);

                }else if(key.isReadable()){
                        m1(key);
                }
            }
        }
    }

    private void m1(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();

        ByteBuffer buffer = ByteBuffer.allocate(10);
        channel.read(buffer);
        System.out.println("服务端的消息为:"+new String(buffer.array()));

        ByteBuffer outBuffer = ByteBuffer.wrap(new String("aaa").getBytes());
        channel.write(outBuffer);
    }

    public static void main(String[] args) throws Exception {
        ChatClient client = new ChatClient();

        client.ininCliect("127.0.0.1",8989);
        client.listen();
    }

}