Question

大家好日子！

我的问题是关于基于NIO的服务器，我的情况如下：服务器从100个客户端（100个客户端线程）读取消息，每个客户端线程发送100条消息。所以，消息总数是100x100 = 10000.我的服务器中有传入消息计数器，在从某个客户端读取一些消息后会增加。当我刚读取消息时，我的服务器读取大约9200条消息。当我为模拟服务延迟添加虚拟循环时，我的服务器惊人地为所有10000条消息提供服务！

我的期望是这样的 - 好吧，服务器设法读取所有10000条消息，即使延迟很短。因此，没有这个延迟服务器可能会读取更多消息（服务更多的客户端）。但是你看，这是错误的。毫不拖延事情变得更糟。 Here我描述了我的建筑。我当前逻辑中唯一的修改是将接受客户端和读取消息分成两个不同的线程：一个选择器接受一个线程中的客户端，第二个选择器等待来自其他线程中连接客户端的消息。

客户端代码

public class TCPClient implements Runnable{

private String name;
private static TCPClient[] clients;
private static Thread[] threads;
private int counter = 0;

public TCPClient(String name)
{
  this.name = name;
  this.counter = 0;
}

public static void main(String[] args) throws Exception
{
   clients = new TCPClient[100];
   threads = new Thread[100];
   for(int i=0;i<100;i++) 
   {
       clients[i] = new TCPClient("thread # "+Integer.toString(i));
       threads[i] = new Thread(clients[i]);
       threads[i].start(); 
       // Thread.sleep(500);
   }
   for(int i=0;i<100;i++) 
   {
       threads[i].join();
   }
   for(int i=0;i<100;i++){
       System.out.println("counter = "+clients[i].counter);
   }

}

@Override
public void run()
{
   Socket socket = null;
   OutputStream out = null;

   try
   {
        socket = new Socket();
        socket.connect(new InetSocketAddress("192.168.3.109",2345), 0); 
        out =  socket.getOutputStream();

        byte[] bytes;
        while(counter < 100)
        {
            counter++;
            bytes = (name+ ", message # "+Integer.toString(counter)+System.lineSeparator()).getBytes();
           // System.out.println(counter);
            out.write(bytes); 
            out.flush();
            Thread.sleep(200);
        }
   }
   catch(Exception ex)
   {
            System.out.println(name+" "+Integer.toString(counter));
            ex.printStackTrace(new PrintStream(System.out));
            System.out.println();
   }
    finally
    { 
        if(socket!=null && out!=null)
        {
            try
            {
                socket.close();
                out.close();
            }
            catch(Exception ex)
            {
                System.out.println("client close error");
            }
        }
    }
}

}

服务器代码（信息阅读部分）

@Override
public void run() 
{
    isRunning = true;
    int acc = 0;
    boolean error = false;
    while (isRunning) {
      try 
      {


             selector.select(); 

             Set keys =  selector.selectedKeys();
             Iterator it = keys.iterator(); 
             while(it.hasNext())
             {
                 SelectionKey key = (SelectionKey)it.next();



                 if (key.isReadable())
                 { 
                       //readMessage(key);
                       //key.cancel();

                      // ByteBuffer bbb =  ByteBuffer.allocate(2048);
                      // key.cancel();
                       curTime = System.currentTimeMillis();
                       SocketChannel sc = (SocketChannel) key.channel();
                       // System.out.println("before reading"); 
                       bb.clear();
                       int x =  sc.read(bb); 

                       if(x==-1)
                       {
                           key.cancel();
                           //System.out.println("cancelling key");
                           continue;
                       }

                       counter++;
                      // bb.flip();
                       //System.out.print(decoder.decode(bb).toString());
                     //  Thread.sleep(20);
                       long sum=0;
                       for(int dummy=0;dummy<250000;dummy++)
                       {
                           sum += dummy;
                         //  sum %= 1005;
                       }
                       long delta  = System.currentTimeMillis() - curTime;
                       serviceTime += delta;

                       if(counter>9000)
                       {
                           System.out.println("recieved messages count = "+counter);
                           System.out.println("one message  service time = "+delta+" milliseconds");
                           System.out.println("total service time = "+serviceTime+" milliseconds");
                           System.out.println("sum = "+sum); //11 249 925 000
                       }

                     // selector.wakeup();
                      //key.interestOps(SelectionKey.OP_READ); 


                 } 
             }

             keys.clear();





      } 
      catch (Exception ex) 
      {     
          error = true;  
          System.out.println("error in recieving messages "+ex.getMessage());
          ex.printStackTrace(new PrintStream(System.out));
         // logger.println("error in recieving messages "+ex.getMessage());
         // logger.flush();
      }
      finally
      {
            //if(error) // !!!!!!!!!!! DO NOT STOP THE SERVER EDIT IT LATER
            //stopServer();
      }
    }
}

可能有用的信息 - 客户端每2条消息之间的延迟是200毫秒。当虚拟循环使200000-220000迭代服务器完美运行时。 BTW，200000次迭代约为200 ms - 因为客户端数量为100，因此一个select（）中的延迟为100 * 200000 = 200万次迭代 - 现代PC为200 ms。如果虚拟循环使得少于200000次迭代，则服务器读取〜9200条消息。这种奇怪行为的原因是什么？

Answer 1

这里存在很多问题，很难知道从哪里开始。

当read()返回-1时，您必须关闭该频道。取消密钥是不够的：你刚刚泄漏了一个插座。
如果read()返回一个正整数，那么它是一个读数，你忽略它。你假设你收到了一条完整的信息。
如果您在频道上获得任何IOException I / O操作，则必须关闭该频道。

可能你不接收整个消息，除非你把睡眠放进去。或者当你把睡眠放进去时，你一次收到多条消息，所以你加工得更快。

添加睡眠只会修复你的错误，它没有自己的魔法属性。

tcp服务器的意外行为：为什么添加延迟会增加服务客户端的能力？

1 个答案: