Java客户端/服务器套接字断开的管道

我正在通过套接字创建一个更新客户端，我在服务器端获得了一个Broken Pipe . 服务器接受客户端套接字并使用消息或大字节数组（~180MB）响应同一套接字 . 在本地测试时（同一台机器上的客户端和服务器）都不会发生错误，并且它似乎在发送字节数组时发生 . 我没有在客户端套接字上指定超时，并且在读取完整响应之前不知道它为何关闭 . 这是我第一次使用插座和任何帮助将不胜感激 .

我的客户端套接字代码：

public static Response makeRequest(Request req) throws IOException {
        Response response = null;
        Socket echoSocket = null;
        ObjectOutputStream out = null;
        ObjectInputStream in = null;


            echoSocket = new Socket(serverHost, 10008);
            out = new ObjectOutputStream(echoSocket.getOutputStream());
            in = new ObjectInputStream(
                    echoSocket.getInputStream());

        BufferedReader stdIn = new BufferedReader(
                new InputStreamReader(System.in));



        out.writeObject(req);
        try {
            response = (Response)in.readObject();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       


        out.close();
        in.close();
        stdIn.close();
        echoSocket.close();
        return response;
    }

响应只是一个持有响应的POJO（字符串/字节[]和其他数据）

我的服务器代码（复制了Sun / Oracle站点的示例并将我的代码添加到其中）

public class Server extends Thread {

    private Socket clientSocket;



    public Server(Socket clientSocket) {
        this.clientSocket = clientSocket;
        start();
    }

    public void run()
    {
        {
            System.out.println ("New Communication Thread Started");

            try { 

                ObjectOutputStream out = new ObjectOutputStream(clientSocket.getOutputStream());
                ObjectInputStream in = new ObjectInputStream(clientSocket.getInputStream());

                Request request = null;
                try {
                    request = (Request)in.readObject();
                } catch (ClassNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                UpdateDAO dao = new UpdateDAO();
                ClientDAO cdao = new ClientDAO();
                Update update = null;
                Client client = null;
                Session s = HibernateUtil.currentSession();
                Transaction t = s.beginTransaction();

                if (request != null) {
                    client = cdao.getClient(request.getClientId());
                    LogItem log = new LogItem();
                    log.setClient(client);
                    log.setTimestamp(new Date());
                    log.setAction(request.getAction());

                    if (request.getResponse() != null) {
                        update = dao.getUpdate(request.getResponse().getUpdateId());
                    }

                    TaskContext ctx = new TaskContext(request, client, update, log);
                    System.out.println("Action: " + request.getAction().getDescription());
                    Task task = TaskFactory.getTask(request.getAction());
                    System.out.println(task.getClass().getName());
                    Response response = task.perform(ctx);



                    out.writeObject(response);

                    log.setClientTaskDescription(request.getMessage());
                    log.setUpdate(ctx.getUpdate());
                    dao.save(ctx.getLog());
                    if (ctx.getUpdate() != null) {
                        dao.update(ctx.getUpdate());
                    }

                } else {
                    out.writeObject(new Response("what"));

                }

                t.commit();

                out.close(); 
                in.close(); 
                clientSocket.close(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace();
                System.exit(1); 
            } 
        }
    }


    public static void main(String[] args) throws IOException 
    { 
        ServerSocket serverSocket = null; 

        try { 
            serverSocket = new ServerSocket(10008); 

            System.out.println ("Connection Socket Created");
            try { 
                while (true)
                {
                    System.out.println ("Waiting for Connection");
                    new Server (serverSocket.accept()); 
                }
            } 
            catch (IOException e) 
            { 
                System.err.println("Accept failed."); 
                System.exit(1); 
            } 
        } 
        catch (IOException e) 
        { 
            System.err.println("Could not listen on port: 10008."); 
            System.exit(1); 
        } 
        finally
        {
            try {
                serverSocket.close(); 
            }
            catch (IOException e)
            { 
                System.err.println("Could not close port: 10008."); 
                System.exit(1); 
            } 
        }
    }

}