NIO笔记(七)之读事件问题

最新推荐文章于 2023-04-19 18:43:46 发布
最新推荐文章于 2023-04-19 18:43:46 发布
阅读量564 收藏 1
点赞数
分类专栏： # NIO编程 文章标签： NIO OP_WRITE 读事件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usagoole/article/details/89762372
版权

文章目录

读事件独立线程处理的问题

  1. 当把读事件放到单独的线程中执行，要注意，读事件的的延迟问题,即如果没有及时处理(将数据从Channel中读取处理)又没有将其注销，那么下一次迭代的时候，依然会触发读事件，这可能会产生一些问题

    public class ReadEvent {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;


    public ReadEvent() throws IOException {
        init();
    }

    public void init() throws IOException {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().setReuseAddress(true);
        serverSocketChannel.bind(new InetSocketAddress(8888));
        System.out.println("启动服务并绑定端口");

    }

    private void handler() throws IOException {
        SocketChannel channel = serverSocketChannel.accept();
        channel.configureBlocking(false);
        System.out.println("接收一个新连接");

        selector = Selector.open();
        channel.register(selector, SelectionKey.OP_READ);
        while (true) {
            int n = selector.select();
            System.out.println(n);
            if (n == 0) {
                continue;
            }
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
            while (keyIterator.hasNext()) {
                SelectionKey selectionKey = keyIterator.next();
                System.out.println(selectionKey);
                keyIterator.remove();

                if (selectionKey.isReadable()) {
                    System.out.println("处理读事件");
                    try {
                        /**
                         * 防止起了太多的线程,因为ReadTask执行有2s的延迟，所以此处如果
                         * 不休眠会导致ReadTask不断的创建，即主要为了防止启动太多的线程
                         */
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    /**
                     * 因为是多线程，可能读事件还没处理(将数据从 channel 中读取处理)，主线程就结束了
                     * 那么下一次迭代的时候, 仍然会触发读事件, 这样一个 channel 中的数据就会被多个线程进行处理
                     */
                    new ReadTask(selectionKey).start();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new ReadEvent().handler();
    }

}

class ReadTask extends Thread {
    private SelectionKey key;
    private String name;
    private Charset charset = Charset.forName("UTF-8");
    private static final AtomicInteger COUNTER = new AtomicInteger(1);

    public ReadTask(SelectionKey key) {
        this.key = key;
        this.name = "ReadTask-" + COUNTER.getAndAdd(1);
    }

    @Override
    public void run() {
        //模拟读延迟
        mockReadDelay(2000);

        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(64);
        try {
            int size = channel.read(buffer);
            buffer.flip();
            System.err.println(String.format("%s读取%s bytes，消息内容:%s", name, size, this.decode(buffer)));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String decode(ByteBuffer buffer) {
        CharBuffer charBuffer = charset.decode(buffer);
        return charBuffer.toString();
    }

    public void mockReadDelay(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

  2. 输出结果如下，可以看出因为读事件线程的延迟处理(从Channel中读取数据)导致读事件被触发了三次，三个不同的线程来处理。

    启动服务并绑定端口
接收一个新连接
1
sun.nio.ch.SelectionKeyImpl@4617c264
处理读事件
1
sun.nio.ch.SelectionKeyImpl@4617c264
处理读事件
1
sun.nio.ch.SelectionKeyImpl@4617c264
处理读事件
ReadTask-1读取5 bytes，消息内容:Aaaaa
ReadTask-2读取0 bytes，消息内容:
ReadTask-3读取0 bytes，消息内容:

  3. 怎么解决这个问题？通常的做法是服务器收到OP_READ事件之后，在下一次进行select()操作之前会将OP_READ先注销掉，以防止一个连接的读操作被分到多个线程中去.(这里只是实验性质来说明会有这个问题，所以不考虑粘包和拆包)

    public class ReadEvent {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;


    public ReadEvent() throws IOException {
        init();
    }

    public void init() throws IOException {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().setReuseAddress(true);
        serverSocketChannel.bind(new InetSocketAddress(8888));
        System.out.println("启动服务并绑定端口");

    }

    private void handler() throws IOException {
        SocketChannel channel = serverSocketChannel.accept();
        channel.configureBlocking(false);
        System.out.println("接收一个新连接");

        selector = Selector.open();
        channel.register(selector, SelectionKey.OP_READ);
        while (true) {
            int n = selector.select();
            System.out.println(n);
            if (n == 0) {
                continue;
            }
            Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
            while (keyIterator.hasNext()) {
                SelectionKey selectionKey = keyIterator.next();
                System.out.println(selectionKey);
                keyIterator.remove();

                //增加注销操作
                int readyOps = selectionKey.readyOps();
                //&～xx 代表取消事件
                selectionKey.interestOps(selectionKey.interestOps() & ~readyOps);


                if (selectionKey.isReadable()) {
                    System.out.println("处理读事件");
                    try {
                        /**
                         * 防止起了太多的线程,因为ReadTask执行有2s的延迟，所以此处如果
                         * 不休眠会导致ReadTask不断的创建，即主要为了防止启动太多的线程
                         */
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    /**
                     * 因为是多线程，可能读事件还没处理(将数据从 channel 中读取处理)，主线程就结束了
                     * 那么下一次迭代的时候, 仍然会触发读事件, 这样一个 channel 中的数据就会被多个线程进行处理
                     */
                    new ReadTask(selectionKey).start();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        new ReadEvent().handler();
    }

}

class ReadTask extends Thread {
    private SelectionKey key;
    private String name;
    private Charset charset = Charset.forName("UTF-8");
    private static final AtomicInteger COUNTER = new AtomicInteger(1);

    public ReadTask(SelectionKey key) {
        this.key = key;
        this.name = "ReadTask-" + COUNTER.getAndAdd(1);
    }

    @Override
    public void run() {
        //模拟读延迟
        mockReadDelay(2000);

        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(64);
        try {
            int size = channel.read(buffer);
            buffer.flip();
            System.err.println(String.format("%s读取%s bytes，消息内容:%s", name, size, this.decode(buffer)));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String decode(ByteBuffer buffer) {
        CharBuffer charBuffer = charset.decode(buffer);
        return charBuffer.toString();
    }

    public void mockReadDelay(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

  4. 输出

    启动服务并绑定端口
接收一个新连接
1
sun.nio.ch.SelectionKeyImpl@4617c264
处理读事件
ReadTask-1读取5 bytes，消息内容:Aaaaa

解决方案

tomcat解决方案

  1. tomcat8.0.30
  2. 每次都将读取到的数据放到一个接收队列中，并且注销OP_READ事件，在处理完请求之后再重新注册OP_READ，等待后续操作。NioEndpoint.Poller#register()
public void register(final NioChannel socket) {
      socket.setPoller(this);
      KeyAttachment ka = new KeyAttachment(socket);
      ka.setPoller(this);
      ka.setTimeout(getSocketProperties().getSoTimeout());
      ka.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
      ka.setSecure(isSSLEnabled());
      PollerEvent r = eventCache.pop();
      ka.interestOps(SelectionKey.OP_READ);//this is what OP_REGISTER turns into.
      if ( r==null) r = new PollerEvent(socket,ka,OP_REGISTER);
      else r.reset(socket,ka,OP_REGISTER);
      //添加到事件队列
      addEvent(r);
}
jannals
关注
专栏目录
NIO笔记(五)之NIO各种事件
jannal专栏
09-10 3565
NIO各种事件 OP_CONNECT OP_ACCEPT OP_WRITE OP_WRITE的处理解决网速慢的连接 OP_READ 特殊的close事件 NIO各种事件 客户端的SocketChannel支持 OP_CONNECT, OP_READ, OP_WRITE三个操作。服务端ServerSocketChannel只支持OP_ACCEPT操作，在服务端由Ser...
NIO学习笔记二
麒麟木木
07-20 2597
NIO中的读和写 NIO中的读和写都是和通道与缓冲区相关联的。从一个通道读取，只需创建一个缓冲区，然后让通道将数据读到这个缓冲区中。写入操作，只需创建一个缓冲区，用数据填充它，然后让通道用这些数据执行写入操作。 从文件中读取 （1）获取通道 （2）创建缓冲区 （3）将数据从通道读入缓冲区 import java.io.FileInputStream; import java.io.IO
Java NIO浅析
美团技术团队
11-04 3330
NIO（Non-blocking I/O，在Java领域，也称为New I/O），是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。 那么NIO的本质是什么样的呢？它是怎样与事件模型结合来解放线程、提高系统吞吐的呢？ 本文会从传统的阻塞I/O和线程池模型面临的问题讲起，然后对比几种常见I...
nio 写事件
当个码农写bug
11-14 716
selector.select() 会阻塞等待4中事件发生 /** * Operation-set bit for read operations. * * &lt;p&gt; Suppose that a selection key's interest set contains * &lt;tt&gt;OP_READ&lt;/tt&gt; at the start of a &...
解决NIO服务端select一直为-1 && 服务端一直有可读事件
博客
12-09 913
  在进行NIO编程的时候，发现客户端只往服务端发送了一条消息后，就下线了，但是服务端select方法的返回值总是1，出现了死循环，经过调试发现，Selectionkeys方法返回的总是进行读操作的SocketChannel，也就是说注册的SocketChannel一直有读的就绪事件，可是客户端已经关闭了。总结来说就是：客户端主动关闭连接，服务端会一直出现可读事件，read一直返回-1，在网上查找...
NIO 中的读和写
weixin_30378311的博客
10-01 157
概述 读和写是I/O的基本过程。从一个通道中读取很简单：只需创建一个缓冲区，然后让通道将数据读到这个缓冲区中。写入也相当简单：创建一个缓冲区，用数据填充它，然后让通道用这些数据来执行写入操作。 从文件中读取 在我们第一个练习中，我们将从一个文件中读取一些数据。如果使用原来的 I/O，那么我们只需创建一个 FileInputStream 并从它那里读取。而在 NIO 中，情况稍...
我的生物系学妹也能听懂的Java NIO中Write事件
JavaEdge全是干货的技术号
05-29 1460
不管系统底层三次连接是否成功，selector都会被唤醒继而触发OP_CONNECT事件，若握手成功，且该连接未被其他线程关闭，finishConnect会返回true，然后就能顺利进行channel读写。要触发写事件，要先向 selector 注册该通道的写事件，跟注册读事件一样，当底层写缓冲区有空闲，就会触发写事件。所以一般只要注册了写事件，就会立马触发，为避免 cpu 空转，在写操作完成后，需将写事件取消，然后下次再有写操作时重新注册写事件。)，也可将数据发出去，但不灵活，可能浪费CPU。
Netty学习之旅------NioSocketChannel源码分析之读事件处理逻辑
m0_69745415的博客
05-04 367
@Override protected int doReadBytes(ByteBuf byteBuf) throws Exception { return byteBuf.writeBytes(javaChannel(), byteBuf.writableBytes());//javaChannel()方法返回的就是java.nio.SocketChannel } 这里涉及到ByteBuf与通道打交道，最终还是会落到java.nio.Channel和java.nio.ByteBuffer上去，所以下文我也
读书笔记：NIO与Socket编程技术指南.zip
最新发布
07-22
读书笔记：NIO与Socket编程技术指南
NIO笔记.doc
01-17
Java NIO（New Input/Output）是Java标准库中提供的一种替代传统IO（基于流的I/O）模型的机制，其设计目标是为了提高程序在处理I/O操作时的性能。NIO的核心概念主要包括通道（Channel）、缓冲区（Buffer）和选择器...
读书笔记：NIO与Socket编程技术指南例子.zip
07-22
读书笔记：NIO与Socket编程技术指南例子
NIO网络编程中重复触发读（写）事件
weixin_34195546的博客
04-25 285
一、前言 　　公司最近要基于Netty构建一个TCP通讯框架， 因Netty是基于NIO的，为了更好的学习和使用Netty，特意去翻了之前记录的NIO的资料，以及重新实现了一遍NIO的网络通讯，不试不知道，一试发现好多细节没注意，导致客户端和服务端通讯的时候出现了一些非常莫名其妙的问题，这边我记录下耗了我一晚上的问题~ 二、正文 　　废话不多说，先上问题代码~ 　　服务端： pack...
Netty——NIO
weixin_57323780的博客
04-19 557
21:16:39 [DEBUG] [main] c.i.n.ChannelDemo6 - 连接已建立: java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:60367]，可以从 channel 将数据读入 buffer，也可以将 buffer 的数据写入 channel，而之前的 stream 要么是输入，要么是输出，channel 比 stream 更为底层。
java nio 事件_只发送了一条16字节的消息，JavaNIO Selector.select（）在建立连接后，一直获取到读事件...
weixin_31241561的博客
02-16 108
public voidStartServer(){try{System.out.println("Trying to Start the Server... ...");ServerSocketChannel serverChannel=ServerSocketChannel.open();serverChannel.bind(new InetSocketAddress(1234));server...
Netty——网络编程 NIO（Selector处理read事件）代码示例
小志的博客
09-01 440
Netty——NIO（Selector处理read事件）代码示例
Java NIO触发方式（一次NIO网络编程实现发现的坑）
The_summers的博客
04-07 355
触发方式简介 在linux的IO多路复用中有水平触发,边缘触发两种模式,这两种模式的区别如下: 水平触发: 只要满足条件，就触发一个事件(只要有数据没有被获取，内核就不断通知你) 边缘触发: 每当状态变化时，触发一个事件。 而Java NIO属于水平触发，即有数据没读完，就会一直触发事件。 举例证明 public void start() { this.init(); ...
27、Nio（selector（cancel（事件取消）））
分享java学习路上的一些笔记，不足之处多多见谅。
11-12 231
Nio（selector（cancel（事件取消）））第一步：当我监听到客户端的连接请求了，但是我们不进行连接（也就是不进行处理）。那么这个服务又陷入了一个非阻塞（线程一直运行） 第二步：剖析select方法（select的逻辑是，若是这个事件已经被处理过了，那么下次就需要新事件了。没有新事件仍然会阻塞（变为阻塞态），但是若是这个事件没有被处理，那么这个select就又会将这这个为处理的selectorkeys这个集合让线程继续处理（进入下面的扫描集合循环））select后这个事件要么处理，要么取消cane
Java中NIO使用上的问题
Chin_Sung的博客
02-13 435
前言 之前一篇文章简单介绍了NIO，并附了一个简单的例子，但是自己试一下就会知道，简单的使用NIO是无法满足开发需要的，因为NIO处理的思路和日常servlet加spring中习惯的一连接一线程有很大不同。 NIO与多线程 上篇那个例子实现了一个简单的NIO，但是实际使用中我们不可能仅仅在单线程下使用，肯定会使用多线程提高处理的效率，但是这样就会有几个难点。 Readable和Writea...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值