The SOMAXCONN value of the current machine.  If failed to get the value, <code>defaultBacklog</code> argument is
used
511547
public static int getTcpBacklog(int tcpBacklog) {
        // Taken from netty.

        // As a SecurityManager may prevent reading the somaxconn file we wrap this in a privileged block.
        //
        // See https://github.com/netty/netty/issues/3680
        return AccessController.doPrivileged((PrivilegedAction<Integer>) () -> {
            // Determine the default somaxconn (server socket backlog) value of the platform.
            // The known defaults:
            // - Windows NT Server 4.0+: 200
            // - Linux and Mac OS X: 128
            final File file = new File(TCP_BACKLOG_SETTING_LOCATION);
            try (BufferedReader in = new BufferedReader(new FileReader(file))) {
                return Integer.parseInt(in.readLine().trim());
            } catch (SecurityException | IOException | NumberFormatException | NullPointerException e) {
                return tcpBacklog;
            }
        });

    }
322196
@Override
    public String getConnectionProximity() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getConnectionProximity");
        String connectionProximity = jcaConnectionFactory.getConnectionProximity();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getConnectionProximity", connectionProximity);
        return connectionProximity;
    }
1295569
public static String getSystemProperty(String name, String defaultValue) {
        String value;
        value = System.getProperty(name, null);
        if (value != null) {
            return value;
        }
        value = System.getenv(name);
        if (value != null) {
            return value;
        }
        return defaultValue;
    }
1316343
def sys_maxfd():
    
    maxfd = None
    try:
        maxfd = int(resource.getrlimit(resource.RLIMIT_NOFILE)[0])
        if maxfd == resource.RLIM_INFINITY:                                                     # pragma: no cover
            maxfd = None
    except: pass
    if maxfd is None:
        maxfd = sys_maxfd.fallback_maxfd
    return maxfd
1139459
private int maxEntryLengthOf(List<AssertionReport> failureReportList) {
        final Integer maxLength = ofNullable(failureReportList).orElse(Collections.emptyList()).stream()
                        .map(report -> report.toString().length())
                        .max(Comparator.naturalOrder())
                        //.min(Comparator.naturalOrder())
                        .get();
        return maxLength > MAX_LINE_LENGTH ? MAX_LINE_LENGTH : maxLength;
    }
235876
Integer getMaxScaleAct() {

        switch (type) {

            case Types.SQL_DECIMAL :
            case Types.SQL_NUMERIC :
                return ValuePool.getInt(Integer.MAX_VALUE);

            default :
                return getMaxScale();
        }
    }
110218
def GetMemBalloonedMB(self):
        ''''''
        counter = c_uint()
        ret = vmGuestLib.VMGuestLib_GetMemBalloonedMB(self.handle.value, byref(counter))
        if ret != VMGUESTLIB_ERROR_SUCCESS: raise VMGuestLibException(ret)
        return counter.value
1124525
protected int getMaxIndexKeys() throws SQLException {
    if (indexMaxKeys == 0) {
      String sql;
      sql = "SELECT setting FROM pg_catalog.pg_settings WHERE name='max_index_keys'";

      Statement stmt = connection.createStatement();
      ResultSet rs = null;
      try {
        rs = stmt.executeQuery(sql);
        if (!rs.next()) {
          stmt.close();
          throw new PSQLException(
              GT.tr(
                  "Unable to determine a value for MaxIndexKeys due to missing system catalog data."),
              PSQLState.UNEXPECTED_ERROR);
        }
        indexMaxKeys = rs.getInt(1);
      } finally {
        JdbcBlackHole.close(rs);
        JdbcBlackHole.close(stmt);
      }
    }
    return indexMaxKeys;
  }
1269274
public void setExecutorTaskMax(int max)
  {
    if (getThreadMax() < max)
      throw new ConfigException(L.l("<thread-executor-max> ({0}) must be less than <thread-max> ({1})",
                                    max, getThreadMax()));

    if (max == 0)
      throw new ConfigException(L.l("<thread-executor-max> must not be zero."));

    _executorTaskMax = max;
  }
564018
public int maxLogFileSize()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "maxLogFileSize", this);
        if (tc.isEntryEnabled())
            Tr.exit(tc, "maxLogFileSize", new Integer(_maxLogFileSize));
        return _maxLogFileSize;
    }
822488
def _backoff(self, context):
        # type: (ExponentialRetryWithMaxWait,
        #        azure.storage.common.models.RetryContext) -> int
        
        self._backoff_count += 1
        if self._backoff_count == 1:
            self._last_backoff = self.initial_backoff
        else:
            self._last_backoff *= 2
        if self._last_backoff > self.max_backoff and self.reset_at_max:
            self._backoff_count = 1
            self._last_backoff = self.initial_backoff
        return self._last_backoff
1010158
public long getMaxTime() {
    lock.lock();
    try {
      if (printMinMax) {
        return previousIntervalMinMax.maxTime;
      }
      return minMax.maxTime;
    } finally {
      lock.unlock();
    }
  }
1159022
int getMaxActiveMessages()
    {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            final String methodName = "getMaxActiveMessages";
            SibTr.entry(this, TRACE, methodName);
        }

        // The field max active messages is used to represent the default max 
        // active messages, however, on distributed systems we ignore this 
        // setting (as we will control the concurrency ourselves) and return
        // 0 - meaning there is no limit (or 1 if strict message ordering is on).
        // This method is called by the base class constructor when it registers
        // the async consumer with processor.
        int maxActiveMsgs = _strictMessageOrdering ? 1 : 0;

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
        {
          final String methodName = "getMaxActiveMessages";
          SibTr.exit(this, TRACE, methodName, maxActiveMsgs);
        }
        return maxActiveMsgs;
    }
609988
public Optional<OperatorBackPressureStats> getOperatorBackPressureStats(ExecutionJobVertex vertex) {
		synchronized (lock) {
			final OperatorBackPressureStats stats = operatorStatsCache.getIfPresent(vertex);
			if (stats == null || backPressureStatsRefreshInterval <= System.currentTimeMillis() - stats.getEndTimestamp()) {
				triggerStackTraceSampleInternal(vertex);
			}
			return Optional.ofNullable(stats);
		}
	}
746661
public int getMaxFailedDeliveries()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getMaxFailedDeliveries"); 
    
    if (_maxFailedDeliveries < 0)
      _maxFailedDeliveries = definition.getMaxFailedDeliveries();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getMaxFailedDeliveries", Integer.valueOf(_maxFailedDeliveries));
    
    return _maxFailedDeliveries;
  }
918326
public final int getMaxArity() {
    Node params = getParametersNode();
    if (params != null) {
      Node lastParam = params.getLastChild();
      if (lastParam == null || !lastParam.isVarArgs()) {
        return params.getChildCount();
      }
    }

    return Integer.MAX_VALUE;
  }
1272895
public alluxio.grpc.MountPointInfo getMountPointsOrDefault(
      java.lang.String key,
      alluxio.grpc.MountPointInfo defaultValue) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    java.util.Map<java.lang.String, alluxio.grpc.MountPointInfo> map =
        internalGetMountPoints().getMap();
    return map.containsKey(key) ? map.get(key) : defaultValue;
  }