应用程序客户端服务器，错误的累加器编号

Question

我创建了一个基于套接字的客户端服务器应用程序......这就是它基本上必须做的...... 定义一个基于套接字的客户端服务器应用程序。服务器必须能够同时响应多个客户端。 服务器生成一个正整数值 N，用于连接的每个客户端。 连接时，客户端随机生成一个整数 M。 然后客户端向服务器M发送正整数值。 传输以发送值 -1 结束。 每次客户端完成传输时，服务器将迄今为止从所有客户端接收到的大于 N 的值的数量写入屏幕。 如有必要，管理同步问题。

这就是我设法做到的......不过我有一个疑问...... 当我运行客户端时，它会告诉我它发送了多少正整数，例如 40 ...。然后服务器会告诉我其中有多少大于客户端生成的数字 N，例如 10 ...。但是，如果我再次运行客户端，这会将大于 N 的先前整数与大于 N 的新整数相加，给我一个不正确的结果。 现在我想知道......这是正常的还是我做错了什么？

        package server;
        import java.io.IOException;
        import java.net.ServerSocket;
        import java.net.Socket;
        import java.util.logging.Level;
        import java.util.logging.Logger;


        public class Server {


 public static void main(String[] args) {
      try {
        ServerSocket s = new ServerSocket(5555);
        int N;
        N = (int)(Math.random()*100);
        System.out.println("Server online, il numero N che adopera è : "+N);

        Accumulatore a = new Accumulatore();
        while(true){
        Socket client = s.accept();
        ThreadServer t = new ThreadServer(client,N,a);
        t.start();
        
       
        
        }
        
         
        
           // TODO code application logic here
        } catch (IOException ex) {
          Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
       // TODO code application logic here
     }
     }
   }      




        package server;
        import java.io.*;
        import java.net.Socket;
        import java.util.logging.Level;
        import java.util.logging.Logger;


        public class ThreadServer extends Thread{

       Socket s ;
       int M;
      Accumulatore acc;

      public ThreadServer(Socket s, int M, Accumulatore acc) {
      this.s = s;
      this.M = M;
      this.acc = acc;
        } 

        @Override
       public void run(){
        try {
        DataInputStream data = new DataInputStream(new BufferedInputStream(s.getInputStream()));
        int n;
        while((n = data.readInt())!=-1){
            if(n>M){
                acc.incrementa();
            }
        }
         System.out.println("Valori più grandi di "+M +" ricevuti : "+ acc.getn());
    
        
       data.close();    //////diocaneeeeeeeee
        s.close();
    } catch (IOException ex) {
        Logger.getLogger(ThreadServer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

}





      package client;

      import java.io.DataOutputStream;
      import java.io.IOException;
      import java.io.OutputStream;
      import java.net.Socket;
      import java.util.logging.Level;
      import java.util.logging.Logger;


      public class Client {


      public static void main(String[] args) {
    
      try(Socket client = new Socket("localhost",5555); 
          OutputStream i1 = client.getOutputStream();  
            DataOutputStream out = new DataOutputStream(i1);) {
        
        int M;
        M= (int)(Math.random()*100);
        System.out.println("Invierò "+M+" interi positivi");

        // TODO code application logic here
        for(int i = 0; i<M; i++){
            int l;
            l = (int)(Math.random()*100);
            out.writeInt(l);
            out.flush();
        }
        out.writeInt(-1);
        out.flush();
        
    } catch (IOException ex) {
        Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
    }
     }

      }



        package server;


        public class Accumulatore {

        private int n = 0;    


       synchronized public void incrementa(){
      n++;        
     }
     public int getn(){
      return n;
   }

   }

Answer 1

正如@Armali 在评论中所写 - 它是否错误取决于应用程序要求。应用程序逻辑具有类Accumulatore 的一个实例。此实例在来自客户端的任何连接之前创建，并总结所有即将到来的连接。服务器在创建新连接时使用相同的 Accumulatore 实例。

如果应该为每个连接单独计算数量，您需要在main 方法中接收到新连接时创建一个单独的Accumulatore 实例。类似的东西：

...
N = (int)(Math.random()*100);
System.out.println("Server online, il numero N che adopera è : "+N);
while(true) {
    Socket client = s.accept();
    Accumulatore a = new Accumulatore();
    ThreadServer t = new ThreadServer(client,N,a);
    t.start();
...