Sets the delaytime before attempting reconnect.
Value of 0 disables the delay entirely.

@api
@param integer|null $milliseconds
@return integer
491679
public function setReconnectDelay($milliseconds = null)
    {
        if (is_integer($milliseconds)) {
            $this->_reconnectdelay = $milliseconds;
        } else {
            $this->_reconnectdelay = self::DEF_RECONNECT_DELAY;
        }
        return $this->_reconnectdelay;
    }
1079567
public function setRetryWait($milliseconds)
    {
        $this->retryWait = (int) $milliseconds;
        $this->client->getConnection()->setRetryWait($milliseconds);

        return $this;
    }
687421
public void setConnectionTimeout(long connectionTimeout, TimeUnit timeUnit) {
		this.connectionTimeoutInMs = TimeUnit.MILLISECONDS.convert(connectionTimeout, timeUnit);
	}
486225
public function setTimeout ($ms) {
    if (defined('CURLOPT_TIMEOUT_MS')) {
      $this->addCurlOption(CURLOPT_TIMEOUT_MS, $ms);

    } else {
      // older versions of php/libcurl don't have the sub-second timeout
      // functionality. Convert to nearest whole seconds not less than 1.
      $this->addCurlOption(CURLOPT_TIMEOUT, max(1, round($ms / 1000)));
    }
    return $this;
  }
58781
private void reconnectAfter(final long timeInMillis) {
    new Thread() {
      @Override
      public void run() {
        LOGGER.info("Schedule reconnect after {} millis", timeInMillis);
        try {
          Thread.sleep(timeInMillis);
        }
        catch (InterruptedException e) {
        }

        int attempt = 0;
        while (session == null || session.getSessionState().equals(SessionState.CLOSED)) {
          try {
            LOGGER.info("Reconnecting attempt #{} ...", ++attempt);
            session = newSession();
          }
          catch (IOException e) {
            LOGGER.error("Failed opening connection and bind to " + remoteIpAddress + ":" + remotePort, e);
            // wait for a second
            try {
              Thread.sleep(1000);
            }
            catch (InterruptedException ee) {
            }
          }
        }
      }
    }.start();
  }
1226270
public function setConnectTimeout($timeout)
    {
        assert(is_int($timeout));
        assert($timeout >= 0);
        $this->_timeout = $timeout;

        return $this;
    }
804052
public function set(int $timeoutMinutes) : bool
    {
        if ($this->isLocked()) {
            return false;
        }
        $this->setLock($timeoutMinutes);
        return true;
    }
293608
public void set_timeout_millis(final Connection connection, final int millis) throws DevFailed {

		build_connection(connection);

		// Check if TACO device
		if (connection.url.protocol == TACO) {
	    	connection.taco_device.set_rpc_timeout(millis);
	    	return;
		}

		// Else TANGO device
		set_obj_timeout(connection, millis);
    }
1005977
public void setTimeout(int milliseconds)
  {
    if(ctx != null)
    {
      QueryDao dao = (QueryDao) ctx.getBean("queryDao");
      if(dao != null)
      {
        dao.setTimeout(milliseconds);
      }
    }
  }
107663
public function setCurlConnectTimeout($seconds)
    {
        if (!is_numeric($seconds) || $seconds < 0) {
            throw new \InvalidArgumentException('Connect timeout value must be numeric and a non-negative number.');
        }

        $this->curlConnectTimeout = $seconds;
        return $this;
    }
1003161
private static int initializeTimeout() {
//        Integer tmp = java.security.AccessController.doPrivileged(
//                new GetIntegerAction("com.sun.security.ocsp.timeout"));
        Integer tmp = Integer.getInteger("com.sun.security.ocsp.timeout");
        if (tmp == null || tmp < 0) {
            return DEFAULT_CONNECT_TIMEOUT;
        }
        // Convert to milliseconds, as the system property will be
        // specified in seconds
        return tmp * 1000;
    }
846879
public static function ofMilliseconds(int $milliseconds) : Duration
    {
        $seconds = intdiv($milliseconds, LocalTime::MILLIS_PER_SECOND);
        $nanos = ($milliseconds % LocalTime::MILLIS_PER_SECOND) * (LocalTime::NANOS_PER_SECOND / LocalTime::MILLIS_PER_SECOND);

        return self::ofSeconds($seconds, $nanos);
    }
642074
public function addTimeout($millisecond, $callback, $args=null)
    {
        return $this->add($millisecond, static::EV_TIMEOUT, $callback, $args);
    }
169891
function delay(milliseconds, x) {
  return promise.Promise.from(x).then(function(value) {
    return new promise.Promise(function(resolve) {
      return timer(milliseconds, function() {
        resolve(value);
      });
    });
  });
}
360213
public static Timer setTimeout(int milliseconds, TimerCallback callback) {
		TimeoutTimer timeout = new TimeoutTimer(); 
		timeout.setId(nativeSetTimeout(milliseconds, callback, timeout));
		return timeout;
	}
927799
public static function fromMilliseconds($timestamp = null)
    {
        if (! $timestamp) {
            return null;
        }

        return Carbon::createFromTimestamp(self::toSeconds($timestamp));
    }
253563
public function pExpireAt($key, $millisecondsTimestamp) {
        return $this->getHandler($this->judge(__FUNCTION__))->pExpireAt($key, $millisecondsTimestamp);
    }