All Downloads are FREE. Search and download functionalities are using the official Maven repository.

io.honeybadger.org.apache.http.impl.client.AIMDBackoffManager Maven / Gradle / Ivy

There is a newer version: 2.1.2
Show newest version
/*
 * ====================================================================
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * .
 *
 */
package org.apache.http.impl.client;

import java.util.HashMap;
import java.util.Map;

import org.apache.http.client.BackoffManager;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.pool.ConnPoolControl;
import org.apache.http.util.Args;

/**
 * 

The {@code AIMDBackoffManager} applies an additive increase, * multiplicative decrease (AIMD) to managing a dynamic limit to * the number of connections allowed to a given host. You may want * to experiment with the settings for the cooldown periods and the * backoff factor to get the adaptive behavior you want.

* *

Generally speaking, shorter cooldowns will lead to more steady-state * variability but faster reaction times, while longer cooldowns * will lead to more stable equilibrium behavior but slower reaction * times.

* *

Similarly, higher backoff factors promote greater * utilization of available capacity at the expense of fairness * among clients. Lower backoff factors allow equal distribution of * capacity among clients (fairness) to happen faster, at the * expense of having more server capacity unused in the short term.

* * @since 4.2 */ public class AIMDBackoffManager implements BackoffManager { private final ConnPoolControl connPerRoute; private final Clock clock; private final Map lastRouteProbes; private final Map lastRouteBackoffs; private long coolDown = 5 * 1000L; private double backoffFactor = 0.5; private int cap = 2; // Per RFC 2616 sec 8.1.4 /** * Creates an {@code AIMDBackoffManager} to manage * per-host connection pool sizes represented by the * given {@link ConnPoolControl}. * @param connPerRoute per-host routing maximums to * be managed */ public AIMDBackoffManager(final ConnPoolControl connPerRoute) { this(connPerRoute, new SystemClock()); } AIMDBackoffManager(final ConnPoolControl connPerRoute, final Clock clock) { this.clock = clock; this.connPerRoute = connPerRoute; this.lastRouteProbes = new HashMap(); this.lastRouteBackoffs = new HashMap(); } @Override public void backOff(final HttpRoute route) { synchronized(connPerRoute) { final int curr = connPerRoute.getMaxPerRoute(route); final Long lastUpdate = getLastUpdate(lastRouteBackoffs, route); final long now = clock.getCurrentTime(); if (now - lastUpdate.longValue() < coolDown) { return; } connPerRoute.setMaxPerRoute(route, getBackedOffPoolSize(curr)); lastRouteBackoffs.put(route, Long.valueOf(now)); } } private int getBackedOffPoolSize(final int curr) { if (curr <= 1) { return 1; } return (int)(Math.floor(backoffFactor * curr)); } @Override public void probe(final HttpRoute route) { synchronized(connPerRoute) { final int curr = connPerRoute.getMaxPerRoute(route); final int max = (curr >= cap) ? cap : curr + 1; final Long lastProbe = getLastUpdate(lastRouteProbes, route); final Long lastBackoff = getLastUpdate(lastRouteBackoffs, route); final long now = clock.getCurrentTime(); if (now - lastProbe.longValue() < coolDown || now - lastBackoff.longValue() < coolDown) { return; } connPerRoute.setMaxPerRoute(route, max); lastRouteProbes.put(route, Long.valueOf(now)); } } private Long getLastUpdate(final Map updates, final HttpRoute route) { Long lastUpdate = updates.get(route); if (lastUpdate == null) { lastUpdate = Long.valueOf(0L); } return lastUpdate; } /** * Sets the factor to use when backing off; the new * per-host limit will be roughly the current max times * this factor. {@code Math.floor} is applied in the * case of non-integer outcomes to ensure we actually * decrease the pool size. Pool sizes are never decreased * below 1, however. Defaults to 0.5. * @param d must be between 0.0 and 1.0, exclusive. */ public void setBackoffFactor(final double d) { Args.check(d > 0.0 && d < 1.0, "Backoff factor must be 0.0 < f < 1.0"); backoffFactor = d; } /** * Sets the amount of time, in milliseconds, to wait between * adjustments in pool sizes for a given host, to allow * enough time for the adjustments to take effect. Defaults * to 5000L (5 seconds). * @param l must be positive */ public void setCooldownMillis(final long l) { Args.positive(coolDown, "Cool down"); coolDown = l; } /** * Sets the absolute maximum per-host connection pool size to * probe up to; defaults to 2 (the default per-host max). * @param cap must be >= 1 */ public void setPerHostConnectionCap(final int cap) { Args.positive(cap, "Per host connection cap"); this.cap = cap; } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy