public class DriverManager {
    // List of registered JDBC drivers
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    // 该变量被声明为 static, 导致其他类型的数据源设置了 DriverManager 中的该变量后，Hive JDBC 将会使用到其他类型数据源设置的超时时间
    private static volatile int loginTimeout = 0;
    private static volatile java.io.PrintWriter logWriter = null;
    private static volatile java.io.PrintStream logStream = null;
    // Used in println() to synchronize logWriter
    private final static  Object logSync = new Object();

    /* Prevent the DriverManager class from being instantiated. */
    private DriverManager(){}

    /**
     * Sets the maximum time in seconds that a driver will wait
     * while attempting to connect to a database once the driver has
     * been identified.
     *
     * @param seconds the login time limit in seconds; zero means there is no limit
     * @see #getLoginTimeout
     */
    public static void setLoginTimeout(int seconds) {
        loginTimeout = seconds;
    }

    /**
     * Gets the maximum time in seconds that a driver can wait
     * when attempting to log in to a database.
     *
     * @return the driver login time limit in seconds
     * @see #setLoginTimeout
     */
    public static int getLoginTimeout() {
        return (loginTimeout);
    }

    // omitted

// copy loginTimeout from driver manager. Thrift timeout needs to be in millis
private void setupLoginTimeout() {
  long timeOut = TimeUnit.SECONDS.toMillis(DriverManager.getLoginTimeout());
  if (timeOut > Integer.MAX_VALUE) {
    loginTimeout = Integer.MAX_VALUE;
  } else {
    loginTimeout = (int) timeOut;
  }
}

public TSocket(String host, int port, int timeout) {
    this.socket_ = null;
    this.host_ = null;
    this.port_ = 0;
    this.timeout_ = 0;
    this.host_ = host;
    this.port_ = port;
    this.timeout_ = timeout;
    this.initSocket();
}

/**
 * Initializes the socket object
 */
private void initSocket() {
  socket_ = new Socket();
  try {
    socket_.setSoLinger(false, 0);
    socket_.setTcpNoDelay(true);
    socket_.setKeepAlive(true);
    socket_.setSoTimeout(timeout_);
  } catch (SocketException sx) {
    LOGGER.error("Could not configure socket.", sx);
  }
}

/**
 *  Enable/disable {@link SocketOptions#SO_TIMEOUT SO_TIMEOUT}
 *  with the specified timeout, in milliseconds. With this option set
 *  to a non-zero timeout, a read() call on the InputStream associated with
 *  this Socket will block for only this amount of time.  If the timeout
 *  expires, a <B>java.net.SocketTimeoutException</B> is raised, though the
 *  Socket is still valid. The option <B>must</B> be enabled
 *  prior to entering the blocking operation to have effect. The
 *  timeout must be {@code > 0}.
 *  A timeout of zero is interpreted as an infinite timeout.
 *
 * @param timeout the specified timeout, in milliseconds.
 * @exception SocketException if there is an error
 * in the underlying protocol, such as a TCP error.
 * @since   1.1
 * @see #getSoTimeout()
 */
public synchronized void setSoTimeout(int timeout) throws SocketException {
    if (isClosed())
        throw new SocketException("Socket is closed");
    if (timeout < 0)
      throw new IllegalArgumentException("timeout can't be negative");

    getImpl().setOption(SocketOptions.SO_TIMEOUT, timeout);
}