Java客户端块服务器应用程序

我有一个客户机-服务器应用程序。 我通过客户端发送一些信息，服务器读取这些信息，执行一个操作并将结果发送给客户端

当我等待在客户端得到结果时，它阻塞了我的服务器应用程序。服务器接收信息，但不执行我的应用程序。。。 如果我不在我的客户机中等待结果，我的服务器将执行我的应用程序，但是。。。我对我的客户没有结果

附言：这是一个家庭作业，我知道在正常情况下最好使用rmi

这里是我的客户代码：

public static void transfertFile(BufferedReader in,Socket so,long sizeFile) throws IOException{
    BufferedReader buffRes;
    buffRes = new BufferedReader(new InputStreamReader(so.getInputStream()));
    PrintWriter printOut;      
    printOut = new PrintWriter(so.getOutputStream());
    String taille = String.valueOf(sizeFile);
    printOut.println(taille);
    printOut.flush();
    printOut.println("client.Calc");
    printOut.flush();
    printOut.println("add");
    printOut.flush();
    printOut.println("10");
    printOut.flush();
    printOut.println("2");
    printOut.flush();
    String str;
    int n;
    String line;
    System.out.println("file=>"+ "\n\n");
    System.out.println("Sending file...");
    while((line = in.readLine())!= null){
         str = line;
         System.out.println(str);
         printOut.println(str);
         printOut.flush();
    }
    in.close();
    String res="";
    res = buffRes.readLine();
    System.out.println("res:"+res);
}

现在，我在服务器中的第一个功能（只需接收要执行的文件和信息）：

以及我的第二个执行方法并将结果发送给客户端的函数：

public void reflexion(String[] param, OutputStream out) {
        String className = param[0];
        Class saClass;
        try {
            saClass = Class.forName(className);
            try {
                Object obj = saClass.newInstance();
                try {
                    Method m = saClass.getMethod(param[1], int.class, int.class);
                    int res;
                    try {
                        Object[] args = {Integer.parseInt(param[2]), Integer.parseInt(param[3])};
                        res = (int) m.invoke(obj, args);
                        String taille = Integer.toString(res);
                        taille = "Le resultat du calcul est:"+res+"\r";
                        System.out.println(taille);
                        System.out.println("Envoie du resultat...");
                        PrintWriter printOut;
                        printOut = new PrintWriter(out);
                        printOut.flush();
                        printOut.checkError();
                        printOut.print(taille);
                        printOut.flush();
                        printOut.close();
                        System.out.println("fin");
                    } catch (IllegalArgumentException ex) {
                        Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (InvocationTargetException ex) {
                        Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                    }
                } catch (NoSuchMethodException ex) {
                    Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                } catch (SecurityException ex) {
                    Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                }

            } catch (InstantiationException ex) {
                Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
        }



    }

---

我最终决定关闭我的套接字，并在将结果发送给我的客户机后再次打开它。

---

它不会阻止我的服务应用程序，我可以收到结果

通常，当建立连接时，服务器应该生成不同的线程并在该线程中处理连接。在主线程中，服务器将自己放在端口上再次侦听。它是一个多线程服务器。我不知道你在说什么。我应该有一个用于输入的线程和一个用于输出的线程？去掉所有那些flush（）调用，除了每种情况下的最后一个调用。你把TCP/IP逼疯了。您应该只在请求或响应结束时刷新。

public void reflexion(String[] param, OutputStream out) {
        String className = param[0];
        Class saClass;
        try {
            saClass = Class.forName(className);
            try {
                Object obj = saClass.newInstance();
                try {
                    Method m = saClass.getMethod(param[1], int.class, int.class);
                    int res;
                    try {
                        Object[] args = {Integer.parseInt(param[2]), Integer.parseInt(param[3])};
                        res = (int) m.invoke(obj, args);
                        String taille = Integer.toString(res);
                        taille = "Le resultat du calcul est:"+res+"\r";
                        System.out.println(taille);
                        System.out.println("Envoie du resultat...");
                        PrintWriter printOut;
                        printOut = new PrintWriter(out);
                        printOut.flush();
                        printOut.checkError();
                        printOut.print(taille);
                        printOut.flush();
                        printOut.close();
                        System.out.println("fin");
                    } catch (IllegalArgumentException ex) {
                        Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                    } catch (InvocationTargetException ex) {
                        Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                    }
                } catch (NoSuchMethodException ex) {
                    Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                } catch (SecurityException ex) {
                    Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
                }

            } catch (InstantiationException ex) {
                Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(AcceptClient.class.getName()).log(Level.SEVERE, null, ex);
        }



    }