public static SelectorProvider provider() {
    synchronized (lock) {
        // 判断provider是否已经产生，若已产生则直接返回
        if (provider != null)
            return provider;
        // 若未产生，则需要调用AccessController的静态方法doPrivileged，创建一个新的Selector对象
        return AccessController.doPrivileged(
            new PrivilegedAction<SelectorProvider>() {
                public SelectorProvider run() {
                        if (loadProviderFromProperty())
                            return provider;
                        if (loadProviderAsService())
                            return provider;
                        provider = sun.nio.ch.DefaultSelectorProvider.create();
                        return provider;
                    }
                });
    }
}

// 由其基类SelectorImpl中实现
public int select() throws IOException {
    return this.select(0L);
}

public int select(long var1) throws IOException {
    if (var1 < 0L) {
        throw new IllegalArgumentException("Negative timeout");
    } else {
        // slect()无参时默认传入0，实则交给lockAndDoSelect方法去完成，并且令参数为-1
        return this.lockAndDoSelect(var1 == 0L ? -1L : var1);
    }
}

private int lockAndDoSelect(long var1) throws IOException {
    synchronized(this) {
        // 先判断当前的Selector对象是否关闭
        if (!this.isOpen()) {
            throw new ClosedSelectorException();
        } else {
            // 分别以publicKeys以及publicSelectedKeys为锁，最终的实现交给抽象方法doSelect完成；
            int var10000;
            synchronized(this.publicKeys) {
                synchronized(this.publicSelectedKeys) {
                    // doSelect方法由WindowsSelectorImpl实现
                    var10000 = this.doSelect(var1);
                }
            }
            return var10000;
        }
    }
}

// channelArray是一个SelectionKeyImpl数组，SelectionKeyImpl负责记录Channel和SelectionKey状态
// channelArray是根据连接的Channel数量动态维持的，初始化大小是8。
private SelectionKeyImpl[] channelArray = new SelectionKeyImpl[8];

protected int doSelect(long var1) throws IOException {
    if (this.channelArray == null) {
        throw new ClosedSelectorException();
    } else {
        this.timeout = var1;
        // 调用processDeregisterQueue方法来取消准备撤销的集合
        this.processDeregisterQueue();
        if (this.interruptTriggered) {
            // 若是发生了中断，调用resetWakeupSocket方法恢复中断
            this.resetWakeupSocket();
            return 0;
        } else {
            // 未发生中断，调用adjustThreadsCount调整轮询线程数量
            this.adjustThreadsCount();
            this.finishLock.reset();
            this.startLock.startThreads();

            try {
                this.begin();

                try {
                    this.subSelector.poll();
                } catch (IOException var7) {
                    this.finishLock.setException(var7);
                }

                if (this.threads.size() > 0) {
                    this.finishLock.waitForHelperThreads();
                }
            } finally {
                this.end();
            }

            this.finishLock.checkForException();
            this.processDeregisterQueue();
            int var3 = this.updateSelectedKeys();
            this.resetWakeupSocket();
            return var3;
        }
    }
}

public static void main(String[] args) throws Exception {
    try {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8000));
        ssc.configureBlocking(false);

        Selector selector = Selector.open();
        // 注册 channel，并且指定感兴趣的事件是 Accept
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        ByteBuffer readBuff = ByteBuffer.allocate(1024);
        ByteBuffer writeBuff = ByteBuffer.allocate(128);
        writeBuff.put("received".getBytes());
        writeBuff.flip();

        while (true) {
            int nReady = selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();

            while (it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();

                if (key.isAcceptable()) {
                    // 创建新的连接，并且把连接注册到selector上
                    // 声明这个channel只对读操作感兴趣。
                    SocketChannel socketChannel = ssc.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }
                else if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    readBuff.clear();
                    socketChannel.read(readBuff);

                    readBuff.flip();
                    System.out.println("received : " + new String(readBuff.array()));
                    key.interestOps(SelectionKey.OP_WRITE);
                }
                else if (key.isWritable()) {
                    writeBuff.rewind();
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    socketChannel.write(writeBuff);
                    key.interestOps(SelectionKey.OP_READ);
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) throws Exception {
    try {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8000));

        ByteBuffer writeBuffer = ByteBuffer.allocate(32);
        ByteBuffer readBuffer = ByteBuffer.allocate(32);

        writeBuffer.put("hello".getBytes());
        writeBuffer.flip();


        while (true) {
            Thread.sleep(1000);
            writeBuffer.rewind();
            socketChannel.write(writeBuffer);
            readBuffer.clear();
            socketChannel.read(readBuffer);
        }
    } catch (IOException e) {
    }
}