Java 7 异步 NIO2 服务器上的连接被拒绝

Posted 2023-02-19

【中文标题】Java 7 异步 NIO2 服务器上的连接被拒绝

【英文标题】：Connection refusal on Java7 async NIO2 server

【发布时间】：2012-10-16 14:37:45

【问题描述】：

我使用 java 7 nio2 编写了一个异步套接字服务器。

这是一个服务器的截图。

public class AsyncJava7Server implements Runnable, CounterProtocol, CounterServer
    private int port = 0;
    private AsynchronousChannelGroup group;
    public AsyncJava7Server(int port) throws IOException, InterruptedException, ExecutionException 
        this.port = port;
    

    public void run() 
        try 
            String localhostname = java.net.InetAddress.getLocalHost().getHostName();
            group = AsynchronousChannelGroup.withThreadPool(
                 Executors.newCachedThreadPool(new NamedThreadFactory("Channel_Group_Thread")));

            // open a server channel and bind to a free address, then accept a connection
            final AsynchronousServerSocketChannel asyncServerSocketChannel =
                           AsynchronousServerSocketChannel.open(group).bind(
                                 new InetSocketAddress(localhostname, port));

            asyncServerSocketChannel.accept(null, 
                 new CompletionHandler <AsynchronousSocketChannel, Object>() 
                            @Override
                            public void completed(final AsynchronousSocketChannel asyncSocketChannel, 
                                      Object attachment) 
                                    // Invoke simple handle accept code - only takes about 10 milliseconds.
                                    handleAccept(asyncSocketChannel); 
                                    asyncServerSocketChannel.accept(null, this);
            
                            @Override
                            public void failed(Throwable exc, Object attachment) 
                                System.out.println("***********" + exc  + " statement=" + attachment);  
            
                 );

这是尝试连接的客户端代码的 sn-p...

public class AsyncJava7Client implements CounterProtocol, CounterClientBridge 
    AsynchronousSocketChannel asyncSocketChannel;

    private String serverName= null;
    private int port;
    private String clientName;

    public AsyncJava7Client(String clientName, String serverName, int port) throws IOException 
        this.clientName = clientName;
        this.serverName = serverName;
        this.port = port;
    

    private void connectToServer() 
        Future<Void> connectFuture = null;
        try 
            log("Opening client async channel...");
            asyncSocketChannel = AsynchronousSocketChannel.open();

            // Connecting to server
            connectFuture = asyncSocketChannel.connect(new InetSocketAddress("Alex-PC", 9999));
        catch (Exception ex) 
            ex.printStackTrace();
            throw new RuntimeException(ex);
       
       // open a new socket channel and connect to the server
       long beginTime  = 0;
       try 
           // You have two seconds to connect. This will throw exception if server is not there.
           beginTime = System.currentTimeMillis();
           Void connectVoid = connectFuture.get(15, TimeUnit.SECONDS);
        catch (Exception ex) 
           //EXCEPTIONS THROWN HERE AFTER ABOUT 150 CLIENTS
           long endTime = System.currentTimeMillis();
           long timeTaken = endTime - beginTime;
           log("************* TIME TAKEN=" + timeTaken);
           ex.printStackTrace();
           throw new RuntimeException(ex);
       
 

我有一个触发客户端的测试。

 @Test
 public void testManyClientsAtSametime() throws Exception 
     int clientsize = 150;
     ScheduledThreadPoolExecutor executor = 
            (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(clientsize + 1, 
                new NamedThreadFactory("Test_Thread"));
     AsyncJava7Server asyncJava7Server = startServer();
     List<AsyncJava7Client> clients = new ArrayList<AsyncJava7Client>();
     List<Future<String>> results = new ArrayList<Future<String>>();

     for (int i = 0; i < clientsize; i++) 
         // Now start a client
         final AsyncJava7Client client = 
               new AsyncJava7Client("client" + i, InetAddress.getLocalHost().getHostName(), 9999);
         clients.add(client);
     

     long beginTime = System.currentTimeMillis();
     Random random = new Random();
     for (final AsyncJava7Client client: clients) 
         Callable<String> callable = new Callable<String>() 
             public String call() 
                 ...
                 ... invoke APIs to connect client to server
                 ...
                 return counterValue;
             
     ;

     long delay = random.nextLong() % 10000;  // somewhere between 0 and 10 seconds.
     Future<String> startClientFuture = executor.schedule(callable, delay, TimeUnit.MILLISECONDS);
     results.add(startClientFuture);
 

它适用于大约 100 个客户。在大约 140+ 时，我在客户端中收到大量异常 - 当它尝试连接时。异常是：java.util.concurrent.ExecutionException: java.io.IOException: 远程计算机拒绝网络连接。

我的测试是在一台运行 Windows 7 的笔记本电脑上进行的。当它爆炸时，我检查 TCP 连接，大约有 500 到 600 个连接——没关系。因为我有类似的 JDK 1.0 java.net 套接字程序，可以处理 4,000 个 TCP 连接。

在服务器中没有异常或任何可疑的东西。

所以我不知道这里可能出了什么问题。有什么想法吗？

【问题讨论】：

会不会是你没有正确关闭连接？换句话说，当您刚刚重新启动计算机和运行测试 10 次时，140 左右的限制是否相同？随着您继续运行测试，该限制会降低吗？

【参考方案1】：

尝试使用接受积压限制并将其设置为更高数字的bind 形式。例如：

            final AsynchronousServerSocketChannel asyncServerSocketChannel =
                       AsynchronousServerSocketChannel.open(group).bind(
                             new InetSocketAddress(localhostname, port), 1000);

我不知道默认情况下 win7 的实现限制是多少，但可能是连接被拒绝的原因。

【讨论】：

干得好。默认情况下限制为 50 个连接。你的解决方案奏效了。谢谢。

@dublintech：快速提问 - 您在哪里找到了 50 的默认限制？我只是快速看了一下，但没有看到。

通过实验。我发现在您发帖之前是 50，但不知道您的解决方案。