设置套接字操作的超时

Question

当我创建一个套接字时：

Socket socket = new Socket(ipAddress, port);

它抛出一个异常，这没关系，因为IP地址不可用。 （String ipAddress = "192.168.0.3" 和int port = 300 所在的测试变量。）

问题是：如何将其设置为该套接字的超时？

当我创建套接字时，如何减少获得UnknownHostException 并使套接字超时的时间？

Answer 1

您没有为套接字设置超时，而是为在该套接字上执行的操作设置了超时。

例如socket.connect(otherAddress, timeout)

或socket.setSoTimeout(timeout) 用于设置read() 操作的超时时间。

见：http://docs.oracle.com/javase/7/docs/api/java/net/Socket.html

Answer 2

将default constructor 用于Socket，然后使用connect() method。

Answer 3

请改用Socket() constructor 和connect(SocketAddress endpoint, int timeout) method。

在你的情况下，它看起来像：

Socket socket = new Socket();
socket.connect(new InetSocketAddress(ipAddress, port), 1000);

---

引用文档

connect

public void connect(SocketAddress endpoint, int timeout) throws IOException

将此套接字连接到具有指定超时值的服务器。超时为零被解释为无限超时。然后连接将阻塞，直到建立或发生错误。

参数：

endpoint - SocketAddress
timeout - 以毫秒为单位的超时值。

投掷：

IOException - 如果连接期间发生错误
SocketTimeoutException - 如果在连接之前超时到期
IllegalBlockingModeException - 如果此套接字有关联的通道，并且通道处于非阻塞模式
IllegalArgumentException - 如果端点为 null 或者是此套接字不支持的 SocketAddress 子类

因为： 1.4

Answer 4

您可以使用以下解决方案：

SocketAddress sockaddr = new InetSocketAddress(ip, port);
// Create your socket
Socket socket = new Socket();
// Connect with 10 s timeout
socket.connect(sockaddr, 10000);

希望对你有帮助！

Answer 5

由于UnknownHostException，您无法控制超时。这些是 DNS 计时。您只能控制给定有效主机的连接超时。前面的答案都没有正确解决这一点。

但是，当您指定 IP 地址而不是主机名时，我很难相信您真的得到了 UnknownHostException。

EDIT 控制 Java 的 DNS 超时see this answer。

Answer 6

一种解决方案是在不同的线程上执行 DNS 解析，该线程只给定一定的时间来完成。

这里有一个简单的实用程序可以帮助您做到这一点：

public class TimeSliceExecutor {

  public static class TimeSliceExecutorException extends RuntimeException {
    public TimeSliceExecutorException(String message, Throwable cause) {
      super(message, cause);
    }
  }

  public static void execute(Runnable runnable, long timeoutInMillis) {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      Future<?> future = executor.submit(runnable);
      getFuture(future, timeoutInMillis);
    }
    finally {
      if (executor != null) {
        executor.shutdown();
      }
    }
  }

  public static <T> T execute(Callable<T> callable, long timeoutInMillis) {
    ExecutorService executor = Executors.newSingleThreadExecutor();
    try {
      Future<T> future = executor.submit(callable);
      return getFuture(future, timeoutInMillis);
    }
    finally {
      if (executor != null) {
        executor.shutdown();
      }
    }
  }

  public static <T> T getFuture(Future<T> future, long timeoutInMillis) {
    try {
      return future.get(timeoutInMillis, TimeUnit.MILLISECONDS);
    }
    catch (InterruptedException ex) {
      Thread.currentThread().interrupt();
      throw new TimeSliceExecutorException("Interrupton exception", ex);
    }
    catch (ExecutionException ex) {
      throw new TimeSliceExecutorException("Execution exception", ex);
    }
    catch (TimeoutException ex) {
      throw new TimeSliceExecutorException(String.format("%dms timeout reached", timeoutInMillis), ex);
    }
  }
}

然后按照以下思路构建套接字：

private Socket buildSocket() throws IOException {
  final Socket socket = new Socket();
  socket.setSoTimeout(socketTimeout);
  socket.connect(new InetSocketAddress(resolveHost(host, dnsTimeout), port), connectionTimeout);
  return socket;
}

private static InetAddress resolveHost(String host, long dnsTimeout) throws IOException {
  try {
    return TimeSliceExecutor.execute(() -> InetAddress.getByName(host), dnsTimeout);
  }
  catch (TimeSliceExecutor.TimeSliceExecutorException ex) {
    throw new UnknownHostException(host);
  }
}

参考：https://stackoverflow.com/a/70610305/225217