socket的流关闭会导致socket关闭

最新推荐文章于 2022-06-15 11:17:56 发布
最新推荐文章于 2022-06-15 11:17:56 发布
阅读量969 收藏 4
点赞数 6
分类专栏： Java 文章标签： java socket 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cat_2_love_dog/article/details/114550975
版权

项目场景：

模拟TCP写聊天程序，客户端对象有两个方法，speak和listen；服务端对象也有两个方法，speak和listen。当客户端键盘输入"bye"时，表示客户端不再speak，服务端收到客户端的"bye"后，服务端也不再listen。服务端键盘输入"bye"时，表示服务端不再speak，客户端收到客户端的"bye"后，客户端也不再listen。总之，客户端先说bye，服务端回复bye，双方通讯结束。
  • 附上问题代码如下：
    • 客户端聊天者的类：
package com.kuang.net.shangxuetang.chat;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class ClientChatter {
    private String ip;
    private int speakPort;
    private int listenPort;
    private int toPort;
    ServerSocket serverSocket;
    Socket socket = null;


    public ClientChatter(String ip,  int toPort) throws IOException {
        this.ip = ip;
        this.toPort = toPort;
        socket = new Socket(InetAddress.getByName(ip), toPort);

    }

    public void speak() throws IOException {
        OutputStream outputStream = socket.getOutputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            while (true){
                String s = bufferedReader.readLine();
                outputStream.write(s.getBytes());
                if("bye".equals(s)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
           if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
    
    public void listen() throws IOException {
        byte[] bytes = new byte[1024];
        int temp=0;
        String content="";
        InputStream inputStream = socket.getInputStream();
        try {
            while (true){
                if((temp=inputStream.read(bytes))!=-1){
                    content=new String(bytes,0,temp);
                    System.out.println("服务端说："+content);
                }
                if("bye".equals(content)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • 服务端聊天者的类：
package com.kuang.net.shangxuetang.chat;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class ServerChatter {
    private int listenPort;
    ServerSocket serverSocket;
    Socket accept = null;


    public ServerChatter(int listenPort) throws IOException {
        this.listenPort = listenPort;
        serverSocket = new ServerSocket(listenPort);
        accept = serverSocket.accept();
    }

    public void speak() throws IOException {
        OutputStream outputStream = accept.getOutputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            while (true){
                String s = bufferedReader.readLine();
                outputStream.write(s.getBytes());
                if("bye".equals(s)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
    
    public void listen() throws IOException {
        byte[] bytes = new byte[1024];
        int temp=0;
        String content="";
        InputStream inputStream = accept.getInputStream();
        try {
            while (true){
                if((temp=inputStream.read(bytes))!=-1){
                    content=new String(bytes,0,temp);
                    System.out.println("客户端说："+content);
                }
                if("bye".equals(content)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • 创建客户端聊天者对象，其两个线程，一个听一个说：
package com.kuang.net.shangxuetang.chat;

import java.io.IOException;

public class TestChatterClient {
    public static void main(String[] args) throws IOException {
        ClientChatter clientChatter = new ClientChatter("127.0.0.1",1000);


        new Thread(()->{
            try {
                clientChatter.speak();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                clientChatter.listen();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }
}
  • 创建服务端聊天者对象，其两个线程，一个听一个说：
package com.kuang.net.shangxuetang.chat;

import java.io.IOException;

public class TestChatterServer {
    public static void main(String[] args) throws IOException {
        ServerChatter serverChatter = new ServerChatter(1000);

        new Thread(()->{
            try {
                serverChatter.speak();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(()->{
            try {
                serverChatter.listen();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

    }
}

问题描述：

当客户端键盘输入"bye"时，服务端能收到"bye"，但是客户端的listen方法报错Socket closed ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210308214524240.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NhdF8yX2xvdmVfZG9n,size_16,color_FFFFFF,t_70)

原因分析：

多次尝试后发现，把speak和listen方法里finally里的关闭流注释掉，就不报错了。
经过查询得知，Java的socket是一个全双工套接字，任何的输入流或输出流的close()都会造成Socket关闭。

解决方案：

将socket的输入输出流提到对象中作为参数，等speak和listen线程都结束后，在主函数里关闭流。

等speak和listen线程都结束后，在主函数里关闭流可以用CountDownLatch实现。具体代码如下：

  • 客户端聊天者的类：
package com.kuang.net.shangxuetang.chat;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class ClientChatter {
    private String ip;
    private int toPort;
    ServerSocket serverSocket;
    Socket socket = null;
    InputStream inputStream = null;
    OutputStream outputStream = null;


    public ClientChatter(String ip,  int toPort) throws IOException {
        this.ip = ip;
        this.toPort = toPort;
        socket = new Socket(InetAddress.getByName(ip), toPort);
        inputStream = socket.getInputStream();
        outputStream = socket.getOutputStream();
    }

    public InputStream getInputStream() {
        return inputStream;
    }

    public OutputStream getOutputStream() {
        return outputStream;
    }

    public Socket getSocket() {
        return socket;
    }

    public void speak() throws IOException {
        OutputStream outputStream = socket.getOutputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            while (true){
                String s = bufferedReader.readLine();
                outputStream.write(s.getBytes());
                if("bye".equals(s)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
/*           if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }*/
            if(bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
    
    public void listen() throws IOException {
        byte[] bytes = new byte[1024];
        int temp=0;
        String content="";
        InputStream inputStream = socket.getInputStream();
        try {
            while (true){
                if((temp=inputStream.read(bytes))!=-1){
                    content=new String(bytes,0,temp);
                    System.out.println("服务端说："+content);
                }
                if("bye".equals(content)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
/*            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }*/
        }
    }
}
  • 服务端聊天者的类：
package com.kuang.net.shangxuetang.chat;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class ServerChatter {
    private int listenPort;
    ServerSocket serverSocket;
    Socket accept = null;
    InputStream inputStream = null;
    OutputStream outputStream = null;

    public ServerChatter(int listenPort) throws IOException {
        this.listenPort = listenPort;
        serverSocket = new ServerSocket(listenPort);
        accept = serverSocket.accept();
        inputStream = accept.getInputStream();
        outputStream = accept.getOutputStream();
    }

    public InputStream getInputStream() {
        return inputStream;
    }

    public OutputStream getOutputStream() {
        return outputStream;
    }

    public void speak() throws IOException {
        OutputStream outputStream = accept.getOutputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            while (true){
                String s = bufferedReader.readLine();
                outputStream.write(s.getBytes());
                if("bye".equals(s)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
/*            if(outputStream!=null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }*/
            if(bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



    }
    
    public void listen() throws IOException {
        byte[] bytes = new byte[1024];
        int temp=0;
        String content="";
        InputStream inputStream = accept.getInputStream();
        try {
            while (true){
                if((temp=inputStream.read(bytes))!=-1){
                    content=new String(bytes,0,temp);
                    System.out.println("客户端说："+content);
                }
                if("bye".equals(content)){
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
/*            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }*/
        }
    }
}
  • 创建客户端聊天者对象，其两个线程，一个听一个说：
package com.kuang.net.shangxuetang.chat;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.concurrent.CountDownLatch;

public class TestChatterServer {
    public static void main(String[] args) throws IOException {
        ServerChatter serverChatter = new ServerChatter(1000);
        CountDownLatch countDownLatch = new CountDownLatch(2);

        try {
            new Thread(()->{
                try {
                    serverChatter.speak();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }).start();

            new Thread(()->{
                try {
                    serverChatter.listen();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }).start();

            try {
                //等待，直到计数器归零后再向下执行
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {

            InputStream inputStream = serverChatter.getInputStream();
            OutputStream outputStream = serverChatter.getOutputStream();

            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(outputStream != null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}
  • 创建服务户端聊天者对象，其两个线程，一个听一个说：
package com.kuang.net.shangxuetang.chat;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.concurrent.CountDownLatch;

public class TestChatterClient {
    public static void main(String[] args) throws IOException {
        ClientChatter clientChatter = new ClientChatter("127.0.0.1",1000);
        CountDownLatch countDownLatch = new CountDownLatch(2);

        try {
            new Thread(()->{
                try {
                    clientChatter.speak();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }).start();

            new Thread(()->{
                try {
                    clientChatter.listen();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            }).start();

            try {
                //等待，直到计数器归零后再向下执行
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            OutputStream outputStream = clientChatter.getOutputStream();
            InputStream inputStream = clientChatter.getInputStream();
            Socket socket = clientChatter.getSocket();
            if(outputStream != null){
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }



        }
    }
}
晒太阳的小猫咪
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
socket server关闭时导致socket client也关闭 的原因及解决办法
12-16
socket server关闭时导致socket client也关闭 的原因及解决办法 tcp socket进程结束时,tcp socket客户端也会结束(崩溃)的原因及解决办法
socket输入输出的关闭方式
zz880329的专栏
04-15 4440
今天做socket相关的输入输出.当使用完一个输入或者输出流以后,我想关闭它,但是直接调用 inputstream.close的时候,再次使用会发现抛出异常,告诉你socket closed 查了一下,发现直接关闭流,会导致socket也被关闭. 正确的调用方法是不直接关闭流,而是调用socket的closeinput/closeoutput方法来关闭,这样可以避免socket被关闭的问题
输入流 inputStream close（）后，它所在的Socket也将关闭
caixiexin的专栏
09-21 4220
RT 所以如果后面还要用到Socket的话，最好不要关闭它的输入流
通过Socket读取数据InputStream.read()阻塞问题
echohawk的博客
05-09 5444
通过Socket读取数据InputStream.read()阻塞问题
socket InputStream available()lock的问题
SAN_YUN的专栏
03-28 442
在socket InputStream读取数据的问题记录一文中介绍通过input.available()检测是否有可读的字节，上线之后发现服务器load过高,通过jstack发现大量线程都lock在在SocketInputStream.available()上，见截图：   之前以为input.available()会很耗时，通过打点发现原来是调用input.available()过于频繁...
python socket 超时设置 errno 10054
12-23
python socket.error: [Errno 10054] 远程主机强迫关闭了一个现有的连接。问题解决方案： 前几天使用python读取网页。因为对一个网站大量的使用urlopen操作，所以会被那个网站认定为攻击行为。有时就不再允许下载。...
Java Socket编程??简单的问候服务实现
12-22
　由于JAVA中提供非常多的输入与输出流API，导致很多初学者接触JAVA SOCKET编程时，由于对网络字节通信的本质缺乏了解，直接一个readline()去接受Socket字节流。但是由于发送一方并没有发送/r/n导致一直无
TDH_Socket_Plugin_for_MySQL.zip
07-19
b)也可以通过配置使一个表的写操作被多个线程并发执行,但是可能会导致死锁而进行回滚；c)客户端可以将写请求发给指定的线程执行,可以在客户端那边在逻辑上保证不会死锁 读线程的动态调整 由于采用读写分开以及...
nginx反向代理导致session失效的问题解决
09-29
主要介绍了nginx反向代理导致session失效的问题解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java socket中关闭IO流后，发生什么事？（以关闭输出流为例）
追逐繁星
07-23 668
声明：该博文以socket中，关闭输出流为例进行说明。   为了方便讲解，我们把DataOutputstream dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));中的dout做为Socket输出流的代言。同样的，din是输入流的代言。 可以造成dout被关闭的操作有
socket流的关闭
Myueye的博客
06-15 2610
在使用socket进行全双工通信时，原本以为输入流和输出流是分开关闭的，然而不管关闭哪个都会直接关闭socket;可以使用socket.shutdownInput()和socket.shutdownOutput() 客户端 使用InputStream 进入bebug模式，在执行到 inputStream.close()后进入SocketInputStream的close()方法，而这个方法是关闭socket流 执行reader.close()后，最后也是执行SocketInputStream的close(
socket（5）：select,close,shutdown
哈尼的博客
09-18 653
socket 详解3-select,close,shutdown1. socket接口-select2. socket接口-close/shutdown 1. socket接口-select connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能...
socket关闭close和shutdown
mayue_web的博客
02-22 5213
转载：http://blog.sina.com.cn/s/blog_693de6100101eusw.html 概述 socket关闭有2个方法close，shutdown ，2个方法的用法需要注意 ，他们之间的区别: close-----关闭本进程的socket id，但链接还是开着的，用这个socket id的其它进程还能用这个链接，能读或写这个socket id shutdown–则破坏了s...
小议socket关闭
热门推荐
白一梓的专栏
02-08 1万+
socket编程过程中往往会遇到这样那样的问题，出现了这些问题，有的是由于并发访问量太大造成的，有些却是由于代码中编程不慎造成的。 比如说，最常见的错误就是程序中报打开的文件数过多这个错误。socket建立连接的时候是三次握手，这个大家都很清楚， 但是socket关闭连接的时候，需要进行四次挥手，但很多人对于这四次挥手的具体流程不清楚，吃了很多亏。
如何关闭一个正在accept的ServerSocket？
[email protected]
08-08 624
加入一个ServerSocket正在另一个线程堵塞accept，那如何停止accept或者关闭Socket？ Server socket 设置下超时 setSoTimeout 然后在Listen线程中用interrupt 其实直接close socket也可以，不过会抛出异常，我的意思是有什么比较安全而又简单的办法？难道要加一个标志，然后要关闭的时候把标志设为stop，然后连接lister...
关闭由ServerSocket阻塞的线程的一种方法
Thincor的博客
03-30 878
关闭由于serverSocket监听阻塞住的线程，对于未阻塞的线程简单的设置一个变量stop，每次轮询检测stop的值即可，但是这对于被阻塞的线程是行不通的。由于被阻塞住，根本无法检测stop变量的值。 方法 程序提供了closeClient()方法，在这个方法中，首先设置stop变量为true，然后与本serverSocket建立链接，建立之后立即关闭。这样在run方法中的serverSocke...
ServerSocket
iteye_10403的博客
09-19 715
ServerSocket的构造方法有以下几种重载形式： ServerSocket()throws IOException ServerSocket(int port) throws IOException ServerSocket(int port, int backlog) throws IOException ServerSocket(int port, int backlog, In...
解决Socket端口关闭后监听方法出错
victor_woo的专栏
11-07 1371
1. ServerSocket.accept 2. Socket.InputStream 以上是两个阻塞方法，监听客户端的连接请求和输入流 当用CTRL+C结束程序时，如果执行Socket.close的动作(特别是在ShutDownHook线程中执行)，监听中的方法肯定报错。 解决此问题的方法是： 执行完毕必要的结束处理动作，不要执行关闭动作，则不会报错 让系
Java socket关闭objectoutstream流
最新发布
05-20
当你使用Java Socket编写网络应用程序时，可以...如果您没有关闭ObjectOutputStream流，并且试图关闭底层Socket流，则可能会导致异常或不可预测的行为。因此，始终确保在关闭Socket连接之前关闭ObjectOutputStream流。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值