Java NIO中一方断开连接或shutdownOutput 另一方不断READ事件

最新推荐文章于 2023-09-28 15:41:47 发布
最新推荐文章于 2023-09-28 15:41:47 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlian523/article/details/105009863
版权

文章目录

select循环里，不断有READ就绪事件

服务端代码：

package NonBlocking;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class TestDisconnectServer {
    static ServerSocketChannel serverSocketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(8888));

        selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        int result = 0; int i = 1;
        while ((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey sk = iterator.next();

                if (sk.isAcceptable()) {
                    ServerSocketChannel ss = (ServerSocketChannel)sk.channel();
                    SocketChannel socketChannel = ss.accept();
                    socketChannel.configureBlocking(false);  //也切换非阻塞
                    socketChannel.register(selector, SelectionKey.OP_READ);  //注册read事件
                    System.out.println("接受到新的客户端连接");
                } else if (sk.isReadable()) {
                    System.out.println("有数据可读");
                }

                iterator.remove();
            }
        }
    }
}

客户端代码：

package NonBlocking;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class TestDisconnectClient {
    static SocketChannel socketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8888));
        socketChannel.configureBlocking(false);

        selector = Selector.open();
        socketChannel.register(selector, SelectionKey.OP_READ);
        int result = 0; int i = 1;
        while((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey sk = iterator.next();

                if (sk.isReadable()) {
                    System.out.println("有数据可读");
                }

                iterator.remove();
            }
        }
    }
}
  • 先后运行服务端、客户端，然后没有什么效果，因为双方都没有给对方写入数据。
  • 当你手动停止任意一方时，另一方都会不断收到READ事件。

手动停止服务端，客户端read抛出异常

package NonBlocking;

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;

public class TestDisconnectClient {
    static SocketChannel socketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8888));
        socketChannel.configureBlocking(false);

        selector = Selector.open();
        socketChannel.register(selector, SelectionKey.OP_READ);
        int result = 0; int i = 1;
        while((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey sk = iterator.next();

                if (sk.isReadable()) {
                    System.out.println("有数据可读");
                    SocketChannel canReadChannel = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    try {
                        while (canReadChannel.read(buf) > 0) {
                            buf.flip();
                            System.out.println(new String(buf.array()));
                            buf.clear();
                        }
                    } catch (IOException e) {
                        canReadChannel.close();
                        sk.cancel();
                        System.out.println("检测到远程连接断开");
                        e.printStackTrace();
                    }
                }

                iterator.remove();
            }
        }
    }
}
  • 当canReadChannel.read(buf)抛出异常时，则是连接断开了。需要关闭channel，且取消SelectionKey。

服务端调用close，客户端read返回-1

服务端加一句：

if (sk.isAcceptable()) {
                    ServerSocketChannel ss = (ServerSocketChannel)sk.channel();
                    SocketChannel socketChannel = ss.accept();
                    socketChannel.configureBlocking(false);  //也切换非阻塞
                    socketChannel.register(selector, SelectionKey.OP_READ);  //注册read事件
                    System.out.println("接受到新的客户端连接");
                    
                    socketChannel.close();  //加一句。接受连接后，马上close
                }

客户端修改：

package NonBlocking;

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;

public class TestDisconnectClient {
    static SocketChannel socketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8888));
        socketChannel.configureBlocking(false);

        selector = Selector.open();
        socketChannel.register(selector, SelectionKey.OP_READ);
        int result = 0; int i = 1;
        while((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey sk = iterator.next();

                if (sk.isReadable()) {
                    System.out.println("有数据可读");
                    SocketChannel canReadChannel = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    try {
                        int readResult;
                        while ((readResult = canReadChannel.read(buf)) > 0) {
                            buf.flip();
                            System.out.println(new String(buf.array()));
                            buf.clear();
                        }
                        if (readResult == -1) {  //需要单独检测read返回-1的情况
                            System.out.println("readResult is -1");
                            canReadChannel.close();
                            sk.cancel();
                        }
                    } catch (IOException e) {
                        canReadChannel.close();
                        sk.cancel();
                        System.out.println("检测到远程连接断开");
                        e.printStackTrace();
                    }
                }

                iterator.remove();
            }
        }
    }
}
  • 当服务端对SocketChannel调用close后，客户端会不断有READ事件，且read不抛异常，但返回值为-1。
  • 所以客户端需要加上单独检测read返回-1的逻辑。

调用shutdownOutput后，不断的READ事件

如果一方调用shutdownOutput后，那么连接会处于半关闭状态，另一方也会不断收到READ事件，但表现是canReadChannel.read(buf)的返回值为-1.注意也是不抛出异常。

修改服务端代码：

package NonBlocking;

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

public class TestDisconnectServer {
    static ServerSocketChannel serverSocketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.bind(new InetSocketAddress(8888));

        selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        int result = 0; int i = 1;
        while ((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while(iterator.hasNext()){
                SelectionKey sk = iterator.next();

                if (sk.isAcceptable()) {
                    ServerSocketChannel ss = (ServerSocketChannel)sk.channel();
                    SocketChannel socketChannel = ss.accept();
                    socketChannel.configureBlocking(false);  //也切换非阻塞
                    socketChannel.register(selector, SelectionKey.OP_READ);  //注册read事件
                    System.out.println("接受到新的客户端连接");

                    socketChannel.shutdownOutput();
                } else if (sk.isReadable()) {
                    System.out.println("有数据可读");
                    SocketChannel canReadChannel = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    try {
                        int readResult;
                        while ((readResult = canReadChannel.read(buf)) > 0) {
                            buf.flip();
                            System.out.println(new String(buf.array()));
                            buf.clear();
                        }
                        if (readResult == -1) {  //需要单独检测read返回-1的情况
                            System.out.println("readResult is -1");
                            canReadChannel.close();
                            sk.cancel();
                        }
                    } catch (IOException e) {
                        canReadChannel.close();
                        sk.cancel();
                        System.out.println("检测到远程连接断开");
                        e.printStackTrace();
                    }
                }

                iterator.remove();
            }
        }
    }
}

修改客户端代码：

package NonBlocking;

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;

public class TestDisconnectClient {
    static SocketChannel socketChannel = null;
    static Selector selector = null;

    public static void main(String[] args) throws IOException {
        socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8888));
        socketChannel.configureBlocking(false);

        selector = Selector.open();
        socketChannel.register(selector, SelectionKey.OP_READ);
        int result = 0; int i = 1;
        while((result = selector.select()) > 0) {
            System.out.println(String.format("selector %dth loop, ready event number is %d", i++, result));
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey sk = iterator.next();

                if (sk.isReadable()) {
                    System.out.println("有数据可读");
                    SocketChannel canReadChannel = (SocketChannel)sk.channel();
                    ByteBuffer buf = ByteBuffer.allocate(1024);
                    try {
                        int readResult;
                        while ((readResult = canReadChannel.read(buf)) > 0) {
                            buf.flip();
                            System.out.println(new String(buf.array()));
                            buf.clear();
                        }
                        if (readResult == -1) {  //需要单独检测read返回-1的情况
                            System.out.println("readResult is -1");
                            canReadChannel.close();
                            sk.cancel();
                        }
                    } catch (IOException e) {
                        canReadChannel.close();
                        sk.cancel();
                        System.out.println("检测到远程连接断开");
                        e.printStackTrace();
                    }
                }

                iterator.remove();
            }
        }
    }
}

先后运行服务端、客户端。

客户端效果：

selector 1th loop, ready event number is 1
有数据可读
readResult is -1
//然后程序阻塞在下一次循环的select那里

服务端效果：

selector 1th loop, ready event number is 1
接受到新的客户端连接
selector 2th loop, ready event number is 1
有数据可读
readResult is -1
//然后程序阻塞在下一次循环的select那里

整个流程是这样的：

  1. 三次握手建立成功，服务端检测到ACCEPT事件。
  2. 服务端获得SocketChannel实例后，马上调用了shutdownOutput。
  3. 这使得客户端检测到READ事件，且read结果为-1。
  4. 然后客户端执行canReadChannel.close()，这又使得服务端检测到了READ事件，且read结果也为-1。
anlian523
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java NIO 中文 Java NIO 中文 Java NIO 中文文档
07-15
Java NIO 深入探讨了 1.4 版的 I/O 新特性，并告诉您如何使用这些特性来极大地提升您所写的 Java 代码的执行效率。这本小册子就程序员所面临的有代表性的 I/O 问题作了详尽阐述，并讲解了 如何才能充分利用新的 I/O ...
java nio 断线_NIO 中 检测到 channel 连接断开后的处理方法？
weixin_39612554的博客
02-25 478
如果检测到连接断开，那么 select 循环就会不断有 read 过来。但我现在对这种情况，有点疑问。package NonBlocking;import java.io.IOException;import java.net.InetSocketAddress;import java.nio.ByteBuffer;import java.nio.channels.SelectionKey;imp...
socket.shutdownOutput()的理解
u011403239的博客
02-14 1万+
看某神视频的时候，发现不用socket.shutdownOutput()服务端就会被阻塞，阻塞在如下代码块中： 后面想了下，其实在客户端代码中不调用socket.close()也会导致阻塞。 说回到客户端，如果不加如下代码就会阻塞。因为服务器会一直等待客户端的输出。既然服务器阻塞了，客户端等待着服务器的输出，也会被阻塞，所以导致客户端和服务端都被阻塞。 调用Socket.shutdownOutput()方法后，客户端输出的数据都将被发送，并加上 TCP 的正常连接终止序列（-1，也就是服务端终
论【TCP】网络编程中shutdownOutput()的作用
weixin_44021343的博客
07-19 3751
今天在练习TCP网络编程的时候，客户端可以给服务端发过去消息，服务端也可以接收到消息，但是，之后的服务端将一直处于运行状态，不会向客户端发消息，自然，客户端也接收不到来自于服务端的消息，具体的代码如下： 服务端： package cn.yang.socket; import java.io.BufferedInputStream; import java.io.IOException; impo...
使用PrintWriter、BufferedReader 数据流进行Socket通信， 要执行Socket.shutdownOutput 才能接受数据的问题
weixin_36637758的博客
06-23 323
Socket通信
java中在客户端里面shutdownOutput方法是干什么的
最新发布
weixin_58689039的博客
09-28 342
在Java中，当在客户端使用shutdownOutput方法时，它的作用是关闭套接字的输出流。这意味着客户端将不能再向服务器发送数据，但是仍然可以接收来自服务器的数据。这个方法通常在客户端已经发送完所有数据后使用，用于通知服务器传输的结束。关闭输出流可以保证服务器端能够正确地处理客户端发来的数据，同时也可以释放相关的资源。
关于Socket 客户端和服务端通信，为什么要flush 为什么使用shutdownOutput的问题
温涛的博客
11-14 3221
关于Socket 客户端和服务端通信，为什么要flush 为什么使用shutdownOutput的问题
java NIO 中文开发文档
09-30
Java NIO适用于高性能服务器端和客户端应用，例如在处理高并发连接的网络服务器中，NIO的非阻塞特性使得它成为理想的解决方案。同时，由于其内存管理机制，NIO在处理大数据时也能表现出色。 在学习Java NIO时，这份...
java NIO.zip
06-16
通过注册感兴趣的事件（如读、写或连接就绪）到选择器，当这些事件发生时，选择器会返回一个包含已准备好的通道的`SelectionKey`集合，然后开发者可以逐个处理这些通道，而无需为每个连接创建单独的线程。...
快速了解Java中NIO核心组件
08-28
"快速了解Java中NIO核心组件" Java NIO（Non-blocking I/O）是 Java 语言中用于实现高性能 I/O 操作的技术。NIO 的核心组件包括 Channel、Buffer、Selector 等。下面将对 NIO 的核心组件进行详细介绍。 Channel ...
详解java nio中的select和channel
08-26
Selector 是 Java NIO 中的另一个核心概念，它用来监控多个 Channel 的事件，比如连接建立、数据到达等等。Selector 可以使用一个线程来管理所有的 Channel。 Selector 的使用 Selector 的使用非常简单，首先需要...
Socket中的shutdownOutput别乱加哎
qq_57171384的博客
05-06 2081
Socket注意事项
【netty】Flink Clickhouse 写入失败 Channel output shutdown Broken pipe
九师兄
06-22 584
1.场景1 1.1 概述 我基于：https://github.com/ivi-ru/flink-clickhouse-sink.git 写了一个FLink clickhouse SInk但是，今天报错 2021-06-21 04:37:04,162 ERROR com.dbapp.function.sink.clickhouse.applied.ClickhouseWriter$WriterTask - Error while executing callback, params = Clickhou
flush , shutdownOutput, close有什么区别
qq_37256891的博客
09-07 1471
今天是小弟第一天开通博客，这也就是小弟我的第一篇博文，以后会更加努力，希望各位大婶多多关照，哪里不对的尽情指出来 flush : 冲刷，将存放在流中的数据写到指定文件（不关闭流，可以继续使用），如果想提前把缓存的内容写入指定文件，可以使用 close ： 关闭，关闭前先冲刷一次，然后关闭（会造成socket也被关闭） shutdownOutput ： 单方面关闭输入输出流，不
netty4.0.x源码分析—channel
pingnanlee的专栏
09-23 1万+
备注：本文的分析基于netty 4.0.9final版本，仅对Nio进行分析，因为本人对Socket编程比较感兴趣。 1、channel总体机构图 nio channel的总体结构图如下： 2、关键类和接口分析 2.1  基于NioServerSocketChannel进行分析 1）Channel Channel是顶层接口，继承了AttributeMap, ChannelOut
NIO问题记录-客户端断开连接，服务端循环读取到OP_READ事件
Zhnengneng的博客
03-24 945
NIO客户端循环获取到OP_READ事件
输入输出流的shutdownoutput和shutdowninput方法的使用（文件默认有一个-1的结束标志位）
XiaopinOo的博客
10-29 2927
最近做练习的时候遇到上传文件可以上传成功，但是上传文件之后返回反馈的时候，总是不能成功返回反馈，添加shutdownoutput就可以了， 练习如下： server端代码： public class server { public static void main(String[] args) throws IOException { ServerSocket ss=new Serve
Java NIO中断开连接后不断有OP_READ事件的问题
qq_35540562的博客
03-24 1237
今天在学习java nio的时候碰到了一个奇怪的问题，在客户端断开连接后，出现了不断产生新OP_READ事件的问题。 while(true){ if(selector.select(1000) == 0){ // 断开连接后这里没有延时的效果 System.out.println("=="); ...
POI操作EXCEL，追加或覆盖数据，输入输出流注意事项，jar包的选择
热门推荐
anlian523的博客
05-16 5万+
对于获得行数据，有两种方法createRow和getRow。顾名思义，前者是新建行，后者是获得行。createRow是不管原来这一行原来是不是有原始数据，都会新建一行。getRow是获得原始行数据，如果本来就是空行，那么就获得一个空行。对于获得单元数据，有两种方法createCell和getCell。功能与上述内容类似。所以，当我们想要追加数据，或者是想根据原来的内容修改数据，就应该使用get方法。而想要使用新的数据来直接覆盖掉旧的数据时，就应该使用create方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值