Explorer les limitations de Java

Dans le monde du développement de logiciels, gérer efficacement la consommation des ressources et garantir une utilisation équitable des services sont des considérations importantes pour créer des applications évolutives et robustes. La limitation est la pratique consistant à contrôler la vitesse à laquelle certaines opérations sont effectuées et constitue un mécanisme clé pour atteindre ces objectifs. Dans cet article, nous examinerons en profondeur les différentes manières d'implémenter la limitation en Java et présenterons diverses stratégies avec des exemples pratiques.

Explorer les limites de Java : exemple d'implémentation simple - Partie 1

Gérer efficacement la consommation des ressources et garantir une utilisation équitable des services sont des considérations importantes dans la création d'applications évolutives et robustes.

Dans le monde du développement de logiciels, gérer efficacement la consommation des ressources et garantir une utilisation équitable des services sont des considérations importantes pour créer des applications évolutives et robustes. La limitation est la pratique consistant à contrôler la vitesse à laquelle certaines opérations sont effectuées et constitue un mécanisme clé pour atteindre ces objectifs. Dans cet article, nous examinerons en profondeur les différentes manières d’implémenter la limitation en Java et présenterons diverses stratégies avec des exemples pratiques.

Avertissement : dans cet article, je me concentrerai sur des illustrations simples à un seul thread résolvant des solutions de base.

Comprendre les limites

Les limites impliquent de réguler la fréquence à laquelle certaines actions sont autorisées à se produire. Ceci est particulièrement important dans les situations où le système doit être protégé contre les abus, nécessite une gestion des ressources ou nécessite un accès équitable aux services partagés. Les cas d'utilisation courants de la limitation incluent la limitation du taux de requêtes API, la gestion des mises à jour des données et le contrôle de l'accès aux ressources critiques.

Limiteur de taux de blocage simple - pas destiné à une utilisation en production ! thread.sleep()

Un moyen simple d'implémenter des limites consiste à utiliser cette méthode pour introduire un délai entre les opérations consécutives. Bien que cette méthode soit simple, elle peut ne pas convenir aux scénarios hautes performances en raison de sa nature bloquante. Thread.sleep()

public class SimpleRateLimiter {

    private long lastExecutionTime = 0;
    private long intervalInMillis;

    public SimpleRateLimiter(long requestsPerSecond) {
        this.intervalInMillis = 1000 / requestsPerSecond;
    }

    public void throttle() throws InterruptedException {
        long currentTime = System.currentTimeMillis();
        long elapsedTime = currentTime - lastExecutionTime;

        if (elapsedTime < intervalInMillis) {
            Thread.sleep(intervalInMillis - elapsedTime);
        }

        lastExecutionTime = System.currentTimeMillis();
        // Perform the throttled operation
        System.out.println("Throttled operation executed at: " + lastExecutionTime);
    }
}

Dans cet exemple, cette classe permet d'effectuer un nombre spécifié d'opérations par seconde. Si le temps écoulé entre les opérations est inférieur à l'intervalle configuré, une durée de sommeil est introduite pour atteindre le rythme souhaité. SimpleRateLimiter

Limitation de base des attentes

Commençons par un exemple simple que nous utilisons pour limiter l'exécution d'une méthode. L’objectif est de permettre à la méthode d’être appelée uniquement après un temps de recharge spécifique. wait

public class BasicThrottling {

    private final Object lock = new Object();
    private long lastExecutionTime = 0;
    private final long cooldownMillis = 5000; // 5 seconds cooldown

    public void throttledOperation() throws InterruptedException {
        synchronized (lock) {
            long currentTime = System.currentTimeMillis();
            long elapsedTime = currentTime - lastExecutionTime;

            if (elapsedTime < cooldownMillis) {
                lock.wait(cooldownMillis - elapsedTime);
            }

            lastExecutionTime = System.currentTimeMillis();
            // Perform the throttled operation
            System.out.println("Throttled operation executed at: " + lastExecutionTime);
        }
    }
}

Dans cet exemple, la méthode utilise cette méthode pour faire attendre le thread que la période de recharge soit écoulée. throttledOperationwait

Limites dynamiques avec attentes et notifications

Améliorons l'exemple précédent pour introduire une limitation dynamique, où le temps de recharge peut être ajusté dynamiquement. La production doit avoir la possibilité d’apporter des changements à la volée.

public class DynamicThrottling {

    private final Object lock = new Object();
    private long lastExecutionTime = 0;
    private long cooldownMillis = 5000; // Initial cooldown: 5 seconds

    public void throttledOperation() throws InterruptedException {
        synchronized (lock) {
            long currentTime = System.currentTimeMillis();
            long elapsedTime = currentTime - lastExecutionTime;

            if (elapsedTime < cooldownMillis) {
                lock.wait(cooldownMillis - elapsedTime);
            }

            lastExecutionTime = System.currentTimeMillis();
            // Perform the throttled operation
            System.out.println("Throttled operation executed at: " + lastExecutionTime);
        }
    }

    public void setCooldown(long cooldownMillis) {
        synchronized (lock) {
            this.cooldownMillis = cooldownMillis;
            lock.notify(); // Notify waiting threads that cooldown has changed
        }
    }

    public static void main(String[] args) {
        DynamicThrottling throttling = new DynamicThrottling();

        for (int i = 0; i < 10; i++) {
            try {
                throttling.throttledOperation();
                // Adjust cooldown dynamically
                throttling.setCooldown((i + 1) * 1000); // Cooldown increases each iteration
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Dans cet exemple, nous introduisons la méthode d'ajustement dynamique du temps de recharge. Cette méthode est utilisée pour réveiller tous les threads en attente, leur permettant de vérifier le nouveau temps de recharge. setCooldownnotify

Utilisation des sémaphores Java

Les classes Java peuvent être utilisées comme de puissants outils de limitation. Le sémaphore gère un ensemble de licences, où chaque opération d'acquisition consomme une licence et chaque opération de libération incrémente une licence. Sémaphore

public class SemaphoreRateLimiter {

    private final Semaphore semaphore;

    public SemaphoreRateLimiter(int permits) {
        this.semaphore = new Semaphore(permits);
    }

    public boolean throttle() {
        if (semaphore.tryAcquire()) {
            // Perform the throttled operation
            System.out.println("Throttled operation executed. Permits left: " + semaphore.availablePermits());
            return true;
        } else {
            System.out.println("Request throttled. Try again later.");
            return false;
        }
    }

    public static void main(String[] args) {
        SemaphoreRateLimiter rateLimiter = new SemaphoreRateLimiter(5); // Allow 5 operations concurrently

        for (int i = 0; i < 10; i++) {
            rateLimiter.throttle();
        }
    }
}

Dans cet exemple, la classe utilise a avec le nombre de licences spécifié. Cette méthode tente d'obtenir une licence et autorise l'opération en cas de succès. SemaphoreRateLimiterSemaphorethrottle

Plusieurs exemples dans la boîte

Des frameworks comme Spring ou Redis fournissent une variété de solutions simples.

Spring AOP pour les restrictions de méthodes

En utilisant les capacités de programmation orientée aspect (AOP) de Spring, nous pouvons créer un mécanisme de restriction au niveau de la méthode. Cette approche nous permet d'intercepter les appels de méthode et d'appliquer une logique de limitation.

@Aspect
@Component
public class ThrottleAspect {

    private Map<String, Long> lastInvocationMap = new HashMap<>();

    @Pointcut("@annotation(throttle)")
    public void throttledOperation(Throttle throttle) {}

    @Around("throttledOperation(throttle)")
    public Object throttleOperation(ProceedingJoinPoint joinPoint, Throttle throttle) throws Throwable {
        String key = joinPoint.getSignature().toLongString();

        if (!lastInvocationMap.containsKey(key) || System.currentTimeMillis() - lastInvocationMap.get(key) > throttle.value()) {
            lastInvocationMap.put(key, System.currentTimeMillis());
            return joinPoint.proceed();
        } else {
            throw new ThrottleException("Request throttled. Try again later.");
        }
    }
}

Dans cet exemple, nous avons défini une annotation personnalisée et un aspect AOP() pour intercepter la méthode en utilisant . pour vérifier le temps écoulé depuis le dernier appel et autoriser ou bloquer la méthode en conséquence. @ThrottleThrottleAspect@ThrottleThrottleAspect

Utilisation de Guava RateLimiter

La bibliothèque Guava de Google fournit une classe qui simplifie la mise en œuvre des limites. Il permet de définir le tarif auquel les opérations sont autorisées. RateLimiter

Voyons comment il peut être utilisé pour limiter la méthode : RateLimiter

import com.google.common.util.concurrent.RateLimiter;

@Component
public class ThrottledService {

    private final RateLimiter rateLimiter = RateLimiter.create(5.0); // Allow 5 operations per second

    @Throttle
    public void throttledOperation() {
        if (rateLimiter.tryAcquire()) {
            // Perform the throttled operation
            System.out.println("Throttled operation executed.");
        } else {
            throw new ThrottleException("Request throttled. Try again later.");
        }
    }
}

Dans cet exemple, nous utilisons Guava pour contrôler le taux d'exécution d'une méthode. Cette méthode permet de vérifier si l'opération est autorisée sur la base d'un tarif défini. RateLimiterthrottledOperationtryAcquire

Redis comme mécanisme de limitation

En utilisant un magasin de données externe comme Redis, nous pouvons implémenter un mécanisme de limitation distribué. Cette approche est particulièrement utile dans les environnements de microservices où plusieurs instances doivent coordonner les contraintes.

@Component
public class RedisThrottleService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Value("${throttle.key.prefix}")
    private String keyPrefix;

    @Value("${throttle.max.operations}")
    private int maxOperations;

    @Value("${throttle.duration.seconds}")
    private int durationSeconds;

    public void performThrottledOperation(String userId) {
        String key = keyPrefix + userId;
        Long currentCount = redisTemplate.opsForValue().increment(key);

        if (currentCount != null && currentCount > maxOperations) {
            throw new ThrottleException("Request throttled. Try again later.");
        }

        if (currentCount == 1) {
            // Set expiration for the key
            redisTemplate.expire(key, durationSeconds, TimeUnit.SECONDS);
        }

        // Perform the throttled operation
        System.out.println("Throttled operation executed for user: " + userId);
    }
}

Dans cet exemple, nous utilisons Redis pour stocker et gérer le nombre d'opérations par utilisateur. Cette méthode incrémente le décompte et vérifie si la limite autorisée a été atteinte. performThrottledOperation

Conclusion

La limitation joue un rôle clé dans le maintien de la stabilité et de l'évolutivité de votre application. Dans cet article, nous explorons différentes manières d'implémenter la limitation en Java, y compris des techniques simples d'utilisation et d'application de solutions prêtes à l'emploi. Thread.sleep()Semaphore

Le choix de la stratégie de limitation dépend de facteurs tels que la nature de l'application, les exigences de performances et le niveau de contrôle requis. Lors de la mise en œuvre de restrictions, vous devez trouver un équilibre entre la prévention des abus et la garantie d'une expérience utilisateur réactive et équitable.

Lorsque vous intégrez des mécanismes de limitation dans votre application, envisagez de surveiller et d'ajuster les paramètres en fonction des modèles d'utilisation réels. Au moment de décider de l'implémentation d'une contrainte, certaines questions peuvent survenir, telles que la manière de gérer les situations dans lesquelles une tâche dépasse le délai qui lui est assigné. Dans mon prochain article, je prévois d'explorer des implémentations Java robustes qui répondent de manière exhaustive à divers scénarios.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!