关于nio:Java-NIO-基础四-选择器

从最根底的层面上来看，选择器提供了问询通道是否就绪操作I/O的能力，选择器能够监控注册在下面的多个通道，通道注册时会返回选择键（记录通道与选择器之间的关联关系），选择器管理者这些注册的键、和就绪状态键的汇合

SelectableChannel
所有继承SelectableChannel的通道都能够在选择器中注册，FileChannel没有继承这个类，所以无奈应用选择器

选择键（SelectionKey）选择键是选择器的重点内容，选择器就绪的通道通过返回选择键汇合来告诉

public abstract class SelectionKey {
    public static final int OP_READ
    public static final int OP_WRITE
    public static final int OP_CONNECT
    public static final int OP_ACCEPT
    public abstract SelectableChannel channel();
    public abstract Selector selector();
    public abstract void cancel();
    public abstract boolean isValid();
    public abstract int interestOps();
    public abstract void interestOps(int ops);
    public abstract int readyOps();
    public final boolean isReadable()
    public final boolean isWritable()
    public final boolean isConnectable()
    public final boolean isAcceptable()
    public final Object attach(Object ob)
    public final Object attachment()
}

选择键保护了通道和选择器之间的关联，能够通过选择键获取Channel或Selector，键对象示意一种非凡的关联关系，当这种关系须要终止时，能够调用cancel()办法勾销，调用这个办法时，不会立刻被勾销，而是将这个键放到被勾销的汇合里，当Selector下次调用select()办法时会真正被清理掉。当通道敞开时，选择键会主动被勾销，当选择器敞开时，所有键都会被清理掉。

一个选择器键蕴含有两个筹备好的操作汇合，包含感兴趣的事件汇合instrest和就绪的操作汇合ready，通过掩码保留

感兴趣的事件汇合interestOps()
通常一个键的instrest注册时就曾经确认，然而能够在注册后通过interestOps(newOps)传入一个新的ops来扭转这个值

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

下面的代码注册的键interest蕴含read事件，能够在对通道IO异步解决时，扭转这个ops来长期勾销对read事件的关注，以避免反复解决未解决完的通道

就绪的操作汇合readyOps()
通过这个办法返回就绪的操作，isReadable( )，isWritable( )，isConnectable( )，和isAcceptable( )用来判断这些操作是否就绪，进行下一步的解决

上面列举两个示例来示范选择器的应用
单选择器单线程

public abstract class AbstractNioServer {
    protected final static String CHARSET = "utf-8";
 protected String ip;
 protected Integer port;
 protected Selector selector;
 public AbstractNioServer(String ip, Integer port) {
        this.ip = ip;
 this.port = port;
 }
    /**
 * 客户端连贯申请
 *
 * @param key
 */
 protected abstract void accept(SelectionKey key) throws IOException;
 /**
 * 读取数据
 *
 * @param key
 */
 protected abstract void read(SelectionKey key) throws IOException;
 /**
 * 初始化服务器
 *
 * @throws IOException
 */ public void init() throws IOException {
        //设置服务器地址端口
 SocketAddress address = new InetSocketAddress(this.ip, this.port);
 //创立服务端通道
 ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
 //绑定服务器地址
 serverSocketChannel.bind(address);
 //设置为非阻塞模式
 serverSocketChannel.configureBlocking(false);
 //创立一个选择器
 this.selector = Selector.open();
 //将服务器通道注册到选择器中，ServerSocketChannel只反对accept事件注册，validOps返回16
 serverSocketChannel.register(this.selector, SelectionKey.OP_ACCEPT);
 }
    public void start() throws IOException {
        this.init();
 while (true) {
            int count = this.selector.select();
 if (count == 0) {
                //没有就绪的选择键
 continue;
 }
            Iterator<SelectionKey> iterator = this.selector.selectedKeys().iterator();
 while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
 if (!key.isValid()) {
                    continue;
 }
                if (key.isAcceptable()) {
                    //连贯申请
 accept(key);
 } else if (key.isReadable()) {
                    //批改键的感兴趣事件，避免被 select 反复调用，解决完事件后及时复原
 key.interestOps(key.interestOps() & (~SelectionKey.OP_READ));
 //读取音讯
 read(key);
 }
                iterator.remove();
 }
        }
    }
    /**
 * 复原键的感兴趣事件
 * @param key
 */
 protected void resumeInterOpsRead(SelectionKey key) {
        //还原key的感兴趣事件
 key.interestOps(key.interestOps() | SelectionKey.OP_READ);
 //唤醒selector的select事件
 key.selector().wakeup();
 }
}

public class SingleNioServer extends AbstractNioServer {
    public static void main(String[] args) {
        SingleNioServer server = new SingleNioServer("127.0.0.1", 1008);
 try {
            server.start();
 } catch (IOException e) {
            e.printStackTrace();
 }
    }
    public SingleNioServer(String ip, Integer port) {
        super(ip, port);
 }
    @Override
 protected void accept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
 //SocketChannel反对 read、write、connect 事件注册，validOps返回13=1+4+8
 SocketChannel channel = serverChannel.accept();
 if (channel == null) {
            return;
 }
        System.out.println("新的连贯申请");
 channel.configureBlocking(false);
 //如果是阻塞通道进行注册，会抛出 IllegalBlockingModeException 异样
 channel.register(this.selector, SelectionKey.OP_READ);
 }
    @Override
 protected void read(SelectionKey key) throws IOException {
        SocketChannel channel = (SocketChannel) key.channel();
 try {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
 int len = channel.read(buffer);
 buffer.flip();
 if (len > 0) {
                String str = Charset.forName(CHARSET).decode(buffer).toString();
 System.out.println("客户端音讯：" + str);
 String msg = "音讯已收到";
 byte[] sendData = msg.getBytes(CHARSET);
 ByteBuffer sendBuffer = ByteBuffer.wrap(sendData);
 channel.write(sendBuffer);
 super.resumeInterOpsRead(key);
 } else if (len == -1) {
                System.out.println("socket client close");
 key.cancel();
 channel.close();
 }
        } catch (IOException ex) {
            key.cancel();
 channel.close();
 }
    }
}

单选择器多线程

public class MulitpleNioServer extends AbstractNioServer {
    public static void main(String[] args) throws IOException {
        MulitpleNioServer server = new MulitpleNioServer("127.0.0.1", 1008);
 server.start();
 }
    /**
 * 线程池
 */
 private ExecutorService executorService = Executors.newFixedThreadPool(5);
 public MulitpleNioServer(String ip, Integer port) {
        super(ip, port);
 }
    @Override
 protected void accept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
 //SocketChannel反对 read、write、connect 事件注册，validOps返回13=1+4+8
 SocketChannel channel = serverChannel.accept();
 System.out.println("新的连贯申请");
 channel.configureBlocking(false);
 channel.register(this.selector, SelectionKey.OP_READ);
 }
    @Override
 protected void read(SelectionKey key) throws IOException {
        executorService.submit(new Runnable() {
            @Override
 public void run() {
                readData(key);
 }
        });
 }
    private void readData(SelectionKey key) {
        SocketChannel channel = (SocketChannel) key.channel();
 try {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
 if (channel.isOpen()) {
                if (channel.isConnected()) {
                    int len = channel.read(buffer);
 buffer.flip();
 if (len > 0) {
                        String str = Charset.forName(CHARSET).decode(buffer).toString();
 System.out.println("客户端音讯：" + str);
 String msg = "音讯已收到";
 byte[] sendData = msg.getBytes(CHARSET);
 ByteBuffer sendBuffer = ByteBuffer.wrap(sendData);
 channel.write(sendBuffer);
 } else if (len == -1) {
                        System.out.println("socket client close1");
 key.cancel();
 channel.close();
 }
                    super.resumeInterOpsRead(key);
 }
            }
        } catch (IOException ex) {
            System.out.println("client is close2");
 key.cancel();
 try {
                channel.close();
 } catch (IOException e) {
                e.printStackTrace();
 }
        }
    }
}

关于nio:Java-NIO-基础四-选择器

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于nio:Java-NIO-基础四-选择器

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复