从套接字声明输入/输出流，防止程序继续

Question

好的，所以我已经编写了使用服务器的简单通信程序，实际上比其他任何东西都更能测试，所以我知道它缺少很多东西，但是带有下面的Client类：

public class Client {
    private ObjectInputStream in;
    private ObjectOutputStream out;

    private Socket socket;

    private String server;
    private int port;

    public Client(String ip, int p){
        port = p;
        server = ip;
    }

    public boolean start(){
        try{
            socket = new Socket(server, port);
        }catch(Exception e){
            System.out.println("Exception");
            e.printStackTrace();
            return false;
        }
        try{
            in = new ObjectInputStream(socket.getInputStream());
            out = new ObjectOutputStream(socket.getOutputStream());
            System.out.println("All declared");
        }catch(Exception e){
            System.out.println("Exception");
            e.printStackTrace();
            return false;}
        new LThread().start();
        return true;
    }

    private void sendMessage(Message msg){
        try{
        out.writeObject(msg);
        }catch(Exception e){}
    }

    public static void main(String[] args){
        int portNum = 1500;
        String servers = "localhost";

        Client client = new Client(servers, portNum);

        System.out.println("Client started");

        if(!client.start()){
            System.out.println("Didn't work");
            return;
        }

        System.out.println("Client started again");


        Scanner scan = new Scanner(System.in);

        while(true){
            String i = scan.nextLine();
            client.sendMessage(new Message(2, i));
        }
    }

    class LThread extends Thread{

        public void run(){
            System.out.println("Lthread running");
            while(true){
                try{
                    String message = (String)in.readObject();
                    System.out.println(message);
                }catch(Exception e){
                    e.printStackTrace();}
            }
        }

    }
}

当程序到达声明其ObjectInput和Output Stream的点时，它就停止了。 该程序没有退出，它似乎没有进入catch块，而且我根本无法弄清楚到底是什么原因引起的。 行“全部声明”。 从不打印，但在打印之前进行任何操作。 谁能告诉我为什么我的程序在此时停止运行而没有显示任何错误？

编辑：我认为我的服务器文件中的某处可能有错误，所以这是该类：

public class Server {

    private static int uid;

    private ArrayList<ClientThread> clients;
    private int port;
    private boolean cont;

    public Server(int p){
        port = p;
        clients = new ArrayList<ClientThread>();
    }

    public void start(){
        System.out.println("Started");
        cont = true;
        try{
            ServerSocket srvr = new ServerSocket(port);
            System.out.println("Declared socket");
            while(cont){
                Socket sk = srvr.accept();
                System.out.println("Socket accepted");

                if(!cont)break;

                ClientThread t = new ClientThread(sk);
                clients.add(t);
                t.start();
            }
            try{
                srvr.close();
                for(ClientThread t : clients){
                    t.in.close();
                    t.out.close();
                    t.socket.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }catch(Exception e){

            e.printStackTrace();
        }
    }

    private synchronized void broadcast(String msg){
        for(int i=clients.size(); --i >= 0;){
            ClientThread t= clients.get(i);
                if(!t.writeMsg(msg)){
                    clients.remove(i);
                }
        }
    }

    public static void main(String[] args){
        int portNum = 1500;

        Server server = new Server(portNum);
        server.start();
    }

    class ClientThread extends Thread{
        Socket socket;
        ObjectInputStream in;
        ObjectOutputStream out;
        String name;
        int id;
        Message m;

        ClientThread(Socket s){
            id = ++uid;
            socket = s;
            try{
                System.out.println("Before");
                in = new ObjectInputStream(socket.getInputStream());
                out = new ObjectOutputStream(socket.getOutputStream());
                System.out.println("After");
            }catch(Exception e){
                e.printStackTrace();}
        }

        public void run(){
            boolean c = true;
            while(c){
                try{
                    m = (Message)in.readObject();
                    switch(m.getType()){
                    case 2:
                        broadcast(m.getMessage());
                    }
                }catch (Exception e){
                    e.printStackTrace();}
            }
        }

        public boolean writeMsg(String msg){
            if(!socket.isConnected()){
                return false;
            }
            try{
                out.writeObject(msg);
            }catch(Exception e){
                e.printStackTrace();}
            return true;
        }
    }

}

好吧，另一个编辑。 因此，我将这两个println添加到ClientThread的构造函数中的try语句中，并且就像与client一样，它一直运行到我尝试初始化流，然后才停止。 再次，没有错误，没有任何东西； 它只是完全停止前进。 我无法弄清楚为什么会发生这种情况，但是如果有任何意义，我正在使用Eclipse IDE来运行它。

Answer 1

第一次使用ObjectInputStream和ObjectOutputStream时，我对此深感 困惑 。 问题的根本原因是在构造函数ObjectInputStream中 。 构造函数将从底层流中读取数据，以尝试获取标头信息，例如有线格式版本。

为了防止客户端和服务器无限等待对方先发送信息，您应该反转输入和输出流的顺序，然后显式刷新输出流。 在客户端和服务器中构建流时，以下内容将解决您的问题：

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