MinIO server allows to throttle incoming requests:

- limit the number of active requests allowed across the cluster
- limit the wait duration for each request in the queue

These values are enabled using server's configuration or environment variables.

## Examples

### Configuring connection limit

        return messageBuilderFactory.builder();
    }

    private void logStats(MavenSession session) {
        infoLine('-');

        Instant finish = MonotonicClock.now();

        Duration time = Duration.between(session.getRequest().getStartInstant(), finish);

        String wallClock = session.getRequest().getDegreeOfConcurrency() > 1 ? " (Wall Clock)" : "";

func (config *TierConfigMgr) refreshTierConfig(ctx context.Context, objAPI ObjectLayer) {
	const tierCfgRefresh = 15 * time.Minute
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	randInterval := func() time.Duration {
		return time.Duration(r.Float64() * 5 * float64(time.Second))
	}

	// To avoid all MinIO nodes reading the tier config object at the same
	// time.
	t := time.NewTimer(tierCfgRefresh + randInterval())
	defer t.Stop()

func (a adminAPIHandlers) SiteReplicationNetPerf(w http.ResponseWriter, r *http.Request) {
	durationStr := r.Form.Get(peerRESTDuration)
	duration, _ := time.ParseDuration(durationStr)
	if duration < globalNetPerfMinDuration {
		duration = globalNetPerfMinDuration
	}
	result := siteNetperf(r.Context(), duration)
	adminLogIf(r.Context(), gob.NewEncoder(w).Encode(result))

	QueueDir    string            `json:"queueDir"`
	MaxRetry    int               `json:"maxRetry"`
	RetryIntvl  time.Duration     `json:"retryInterval"`
	Proxy       string            `json:"string"`
	Transport   http.RoundTripper `json:"-"`
	HTTPTimeout time.Duration     `json:"httpTimeout"`

	// Custom logger
	LogOnceIf func(ctx context.Context, err error, id string, errKind ...any) `json:"-"`
}

import assertk.assertions.hasMessage
import assertk.assertions.isEqualTo
import assertk.assertions.isIn
import java.io.IOException
import java.net.InetSocketAddress
import java.net.UnknownHostException
import java.time.Duration
import java.util.Arrays
import java.util.concurrent.TimeUnit
import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop

		r := rand.New(rand.NewSource(time.Now().UnixNano()))
		// Run the data scanner in a loop
		for {
			runDataScanner(ctx, objAPI)
			duration := max(time.Duration(r.Float64()*float64(scannerCycle.Load())),
				// Make sure to sleep at least a second to avoid high CPU ticks.
				time.Second)
			time.Sleep(duration)
		}
	}()
}

func getCycleScanMode(currentCycle, bitrotStartCycle uint64, bitrotStartTime time.Time) madmin.HealScanMode {

	if err != nil {
		concurrent = 32
	}

	duration, err := time.ParseDuration(durationStr)
	if err != nil {
		duration = time.Second * 10
	}

	done := keepHTTPResponseAlive(w)

	result, err := selfSpeedTest(r.Context(), speedTestOpts{
		objectSize:      size,
		concurrency:     concurrent,
		duration:        duration,
		storageClass:    storageClass,
		bucketName:      bucketName,

import assertk.assertions.isTrue
import java.lang.Thread.sleep
import java.util.concurrent.TimeUnit
import kotlin.concurrent.thread
import kotlin.test.assertFailsWith
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.measureTime
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.SocketEffect.CloseSocket

  private final long hitCount;
  private final long missCount;
  private final long loadSuccessCount;
  private final long loadExceptionCount;

  @SuppressWarnings("GoodTime") // should be a java.time.Duration
  private final long totalLoadTime;

  private final long evictionCount;

  /**
   * Constructs a new {@code CacheStats} instance.
   *