socket connect java,Java慢socket.connect()

以下是客户端和服务器的源代码.

客户端只是(并发地)连接到服务器并立即关闭连接.

完成所有线程后,它会等待2分钟并再次连接.

我很困惑,有时一个简单的连接需要大约3秒！

大多数情况下,连接需要大约0-32ms.

这是客户端的典型输出：

...

Connect 23 [ms]: 16

Connect 22 [ms]: 32

Connect 21 [ms]: 32

Connect 15 [ms]: 32

Connect 14 [ms]: 16

Connect 13 [ms]: 16

Connect 11 [ms]: 32

Connect 25 [ms]: 3016

如果客户端和服务器位于不同的主机上,这似乎只会发生.

Windows和Linux可比的行为

Java 1.6.23

要启动服务器2需要参数：

[port] [线程池大小]

要启动客户端3参数是必需的：

[主持人] [端口] [线程池大小]

例如,我为服务器使用了150个线程池大小,为客户端使用了25个线程池大小.

任何人都可以解释这种行为吗？

—–服务器—–

package de.test.server;

import java.io.IOException;

import java.io.InputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class ServerApp {

public static void main(String[] args) throws IOException {

System.out.println("server running...");

final int port = Integer.parseInt(args[0]);

final int threads = Integer.parseInt(args[1]);

final ExecutorService executorService = Executors

.newFixedThreadPool(threads);

ServerSocket serverSocket = new ServerSocket(port);

while (true) {

final Socket clientSocket = serverSocket.accept();

executorService.execute(new Runnable() {

@Override

public void run() {

try {

InputStream is = clientSocket.getInputStream();

int read = is.read();

if (read != -1) {

System.out.println("should not happen");

}

} catch (IOException e) {

throw new RuntimeException(e);

} finally {

close(clientSocket);

System.out.println("connection closed");

}

}

private void close(final Socket connection) {

try {

connection.close();

} catch (IOException e1) {

throw new RuntimeException(e1);

}

};

});

}

}

}

—–客户—–

package de.test.client;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicLong;

public class ConnectApp {

public static void main(String[] args) throws InterruptedException {

final String host = args[0];

final int port = Integer.parseInt(args[1]);

final int THREAD_COUNT = Integer.parseInt(args[2]);

final ExecutorService executorService = Executors

.newFixedThreadPool(THREAD_COUNT);

final AtomicLong threadCounter = new AtomicLong(0);

while (true) {

final CountDownLatch doneSignal = new CountDownLatch(THREAD_COUNT);

for (int i = 0; i < THREAD_COUNT; i++) {

executorService.execute(new Runnable() {

@Override

public void run() {

Socket socket = null;

try {

long start = System.currentTimeMillis();

socket = new Socket();

socket.setTcpNoDelay(true);

socket.connect(new InetSocketAddress(host, port));

System.out.println(socket.getTcpNoDelay());

long stop = System.currentTimeMillis();

System.out.println("Connect "

+ threadCounter.incrementAndGet() + " [ms]: "

+ (stop - start));

} catch (UnknownHostException e) {

throw new RuntimeException(e);

} catch (IOException e) {

throw new RuntimeException(e);

} finally {

close(socket);

doneSignal.countDown();

}

}

private void close(Socket socket) {

try {

if (socket != null)

socket.close();

} catch (IOException e1) {

throw new RuntimeException(e1);

}

}

});

}

doneSignal.await();

System.out.println("Waiting 2 minutes...");

Thread.sleep(1000 * 60 * 2);

}

}

}