1

我想创建一个具有 3 个相互通信的节点的网络。更详细地说，我正在尝试的是：

  • 将服务器-客户端模型创建为单个项目，然后再复制 2 个项目，我有 3 个节点
  • 通过更改端口，即使我将项目拆分在不同的计算机上，我也可以使它们进行通信
  • 之后，我想从一个项目将时间（有一些虚构的时间滞后）发送到其他 2 个节点，反之亦然，从其他 2 个节点发送，然后找到平均时间。
  • 我不想创建单个服务器和单个客户端，我想使用线程来制作一个统一的服务器客户端，它可以通过简单的“运行”运行。

我遇到的问题是首先启动的节点也首先完成，其余节点处于挂起状态并处于无限循环中。还有其他的，我不知道该怎么做。

到目前为止，我已经做到了：

服务器：

public class Server implements Runnable{
    private int port;
    private String name;

    public Server(int port, String name){
        this.port=port;
        this.name=name;
    }
    public synchronized void run(){
        while(true){
        try{

            Thread.sleep(5000);

            method();

        }
        catch(Exception e){
            return;
        }

        }
    }

    public synchronized void method() throws Exception{
        double sum=0;
        double average=0;
        double[] values = new double[10];
      ServerSocket server = new ServerSocket(port);

      Socket s=server.accept();

      InputStream in= s.getInputStream();
      OutputStream out = s.getOutputStream();

      PrintWriter w = new PrintWriter(out);
      Scanner r = new Scanner(in);
      for(int i=0; i<10; i++){
      String msg = r.next();
      sum = Double.parseDouble(msg);
      values[i] = sum;

    }
      for(int j=0; j<values.length; j++){
          average = average + values[j];
      }
      System.out.println(name+": "+average/10);
}
}

客户：

public class Client implements Runnable{
    private int port;
    private int id;
    public Client(int port,int id){
        this.port=port;
        this.id = id;
    }

    public synchronized void run(){

        try{
            Thread.sleep(5000);

            method();

        }
        catch(Exception e){
            return;
        }

    }

    public synchronized void method() throws Exception{
        int num=0;
        Random ran = new Random(10);
        int d = 0;
        Socket s = new Socket("localhost", port);

        InputStream in= s.getInputStream();
        OutputStream out = s.getOutputStream();

        PrintWriter w = new PrintWriter(out);
        Scanner r = new Scanner(in);
        for(int i=0; i<10; i++){
        d = ran.nextInt(10);
        System.out.println("Client "+id+" sent "+d);
        w.println(d);
        w.flush();
        }


    }
}

我像这样运行它们：

public class Networks {


    public static void main(String[] args) {
        Server s = new Server(5000, "Server 0");
        Server s2 = new Server(5001, "Server 1");
        Client c = new Client(5002, 11);
        Client c2 = new Client(5004, 22);

        Thread t1 = new Thread(s);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(c2);
        Thread t4 = new Thread(s2);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

        try{
            t1.join();
            t2.join();
            t3.join();
            t4.join();
        }
        catch(Exception e){
            System.out.println("something");
        }

    }
}

您可能会忽略端口和东西，因为我已经创建了 2 次相同的项目进行测试。另外 method() 方法只是用于测试，我确实得到了结果，但是当我从输出中运行所有 3 个项目时，我得到第一个项目的客户端什么都不发送，我从两个服务器都得到结果，第二个客户端只工作 1 和我只得到 1 个服务器结果，在第三个项目中只有客户端发送，但服务器什么也没返回。当输出完成时，第一个项目完成并结束，另外两个项目永远运行。

4

1 回答 1

2

也许：

  1. 您正在吞噬客户端中的异常。
  2. 您同时启动所有 4 个线程。
  3. 存在竞争条件，客户端可以在服务器侦听/接受之前启动并尝试在套接字上发送
  4. 当服务器启动时，客户端已经出错，服务器将永远等待。

这只是一个理论，但看起来很可能是这样。

于 2013-05-03T15:32:26.103 回答