BestHub
Sign in
Tagged articles

token bucket

109 articles · Page 1 of 2
JavaGuide
JavaGuide
Sep 21, 2026 · Artificial Intelligence

Step 5 Preview Outperforms DeepSeek V4 Pro in Coding Tasks at Fraction of Opus 5 Cost

The article benchmarks StepFun's Step 5 Preview against DeepSeek V4 Pro across three coding challenges—2D animation, token bucket demo, and CSV analysis workbench—revealing Step 5 Preview delivers richer details and better test coverage despite longer generation times, with per-task cost at just 35% of GLM-5.3 and 12.5% of Claude Opus 5.

AI coding benchmarkCSV analysisDeepSeek V4 Pro
0 likes · 23 min read
Step 5 Preview Outperforms DeepSeek V4 Pro in Coding Tasks at Fraction of Opus 5 Cost
Programmer XiaoFu
Programmer XiaoFu
Aug 28, 2026 · Backend Development

Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services

The article analyzes five reasons why Spring Cloud Gateway's Redis-based token bucket rate limiting fails to protect downstream services during traffic bursts, including QPS vs. concurrency confusion, burstCapacity spikes, multi-route quota multiplication, KeyResolver fallback flaws, and Redis bottleneck fail-open behavior, then recommends tightening burst limits, adding downstream concurrency isolation with Sentinel/Resilience4j, and hardening KeyResolver configuration.

Burst TrafficRate LimitingRedis
0 likes · 13 min read
Why Spring Cloud Gateway Rate Limiting Fails to Protect Downstream Services
Programmer1970
Programmer1970
Aug 23, 2026 · Backend Development

Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release

This article details the development of custom Spring Cloud Gateway plugins for rate limiting, circuit breaking, and gray release to overcome Sentinel's production limitations, covering architecture design, Redis-based rule storage with pub/sub, token bucket and sliding window algorithms, circuit breaker state machines, tag-based canary routing, and production lessons learned with performance benchmarks.

Circuit BreakingGray ReleaseRate Limiting
0 likes · 20 min read
Custom Spring Cloud Gateway Filters for Rate Limiting, Circuit Breaking & Gray Release
Xiaolin Talks Programming
Xiaolin Talks Programming
Aug 19, 2026 · Backend Development

Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense

This article details a production-ready distributed rate limiting system using Spring Boot AOP, Redis Sorted Sets, and atomic Lua scripts, covering sliding window and token bucket algorithms, multi-dimensional flash sale protection, and benchmark results showing 100% accuracy with minimal latency overhead.

AOPFlash SaleLua
0 likes · 18 min read
Building Distributed Rate Limiting with Spring Boot, Redis & Lua: Sliding Window, Token Bucket & Flash Sale Defense
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 13, 2026 · Backend Development

Beyond Caching: 10 Advanced Redis Use Cases You’re Probably Missing

This article walks through ten advanced Redis features—including Bloom filters, Redisson distributed locks, delayed queues, token‑bucket rate limiting, bitmaps, HyperLogLog, GEO, Streams, Lua scripts, and RedisJSON—explaining their principles, pros and cons, typical scenarios, and providing complete Spring Boot code examples.

BitmapBloom FilterGEO
0 likes · 23 min read
Beyond Caching: 10 Advanced Redis Use Cases You’re Probably Missing
Random Bulletin
Random Bulletin
Jul 3, 2026 · Operations

From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues

A bulk coupon‑sending job overwhelmed a million‑QPS system, revealing that message queues only buffer but do not shape traffic; the article dissects three failure points, compares leaky‑bucket and token‑bucket rate limiters, evaluates placement on producer, broker or consumer, and progresses from static limits to adaptive shaping with handling of throttled messages.

Rate Limitingadaptive throttlingleaky-bucket
0 likes · 18 min read
From Coarse to Fine-Grained: Traffic Shaping Strategies for Million‑QPS Queues
Random Bulletin
Random Bulletin
Jul 2, 2026 · Operations

From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems

A bulk coupon‑sending job overwhelmed a 10 M‑QPS system, revealing that message queues only buffer traffic; the article walks through why rate‑limiting (leaky vs token bucket) must be added at the producer, broker, or consumer, evolves from static thresholds to adaptive shaping, and discusses how to handle throttled messages.

Rate Limitingadaptive throttlingleaky-bucket
0 likes · 18 min read
From Zero to Control: Implementing Traffic Shaping for 10 Million QPS Systems
Random Bulletin
Random Bulletin
Jun 16, 2026 · Backend Development

Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures

The article explains why consumer‑side rate limiting is essential in million‑QPS systems, detailing how unchecked consumers can overwhelm downstream services, and presents practical strategies—including pause/resume, token‑bucket algorithms, adaptive thresholds, and global coordination—to safely throttle consumption without dropping messages.

KafkaRate Limitingconsumer optimization
0 likes · 16 min read
Consumer Rate Limiting: From Zero to Full Control in Million‑QPS Architectures
Java Tech Workshop
Java Tech Workshop
May 30, 2026 · Backend Development

Implement SpringBoot API Rate Limiting with Gateway and Redis

The article explains why placing rate limiting at the Spring Cloud Gateway layer, using Redis and Lua scripts, provides a high‑performance, distributed defense against traffic spikes, and walks through three algorithms, configuration parameters, code examples, and custom error handling for robust backend services.

LuaRate LimitingRedis
0 likes · 8 min read
Implement SpringBoot API Rate Limiting with Gateway and Redis
Cloud Architecture
Cloud Architecture
Mar 13, 2026 · Backend Development

Mastering Redis Rate Limiting: Token Bucket & Sliding Window Full Implementation Guide

This article provides a comprehensive, production‑ready walkthrough of implementing Redis‑based rate limiting using token bucket and sliding window algorithms, covering algorithm fundamentals, code examples, performance testing, multi‑layer architecture, dynamic configuration, and best‑practice recommendations for high‑traffic backend services.

BackendLuaRate Limiting
0 likes · 43 min read
Mastering Redis Rate Limiting: Token Bucket & Sliding Window Full Implementation Guide
Go Development Architecture Practice
Go Development Architecture Practice
Feb 4, 2026 · Backend Development

Master Go Rate Limiting: Sliding Window, Token Bucket, and Redis Techniques

This article presents four practical Go rate‑limiting implementations—a sliding‑window algorithm, a token‑bucket approach, the built‑in golang.org/x/time/rate package, and a Redis‑backed distributed limiter—complete with code samples, usage guidance, and recommendations for different deployment scenarios.

Rate LimitingRedisgolang.org/x/time/rate
0 likes · 11 min read
Master Go Rate Limiting: Sliding Window, Token Bucket, and Redis Techniques
macrozheng
macrozheng
Jan 20, 2026 · Backend Development

How to Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3

This guide explains how to build a complete multi‑dimensional network bandwidth throttling solution in Spring Boot 3 using a custom token‑bucket algorithm, HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream to precisely control download, video streaming, and API traffic.

BackendHandlerInterceptorJava
0 likes · 14 min read
How to Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3
Java Companion
Java Companion
Jan 15, 2026 · Backend Development

Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3

This article presents a complete Spring Boot 3 solution for multi‑dimensional network bandwidth throttling using a manually implemented token‑bucket algorithm, custom HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream, with detailed code samples, configuration options, and performance tuning guidance.

HandlerInterceptorJavaRate Limiting
0 likes · 13 min read
Implement Multi‑Dimensional Bandwidth Throttling in Spring Boot 3
Java Baker
Java Baker
Nov 27, 2025 · Backend Development

Mastering Rate Limiting: Token Bucket & Sliding Window Algorithms in Java

This article explains the principles and implementation details of common rate‑limiting algorithms—token bucket and sliding‑window counting—including their core concepts, key processes, Java code examples, and how to extend them to distributed scenarios with Redis Lua scripts.

Rate LimitingRedisdistributed
0 likes · 19 min read
Mastering Rate Limiting: Token Bucket & Sliding Window Algorithms in Java
Su San Talks Tech
Su San Talks Tech
Sep 18, 2025 · Backend Development

Designing a Million‑QPS Rate Limiter for Backend System Interviews

This article walks through a complete, interview‑ready design of a high‑performance rate‑limiting system that can handle up to one million queries per second, covering requirements, core entities, algorithm choices, distributed state storage with Redis, scalability, high availability, latency optimization, hot‑key mitigation, and dynamic rule configuration.

High ConcurrencyRate LimitingSystem Design
0 likes · 29 min read
Designing a Million‑QPS Rate Limiter for Backend System Interviews
Architect's Journey
Architect's Journey
Sep 15, 2025 · Backend Development

Token Bucket vs Leaky Bucket: Deep Dive into Core Traffic‑Control Algorithms

This article compares the token‑bucket and leaky‑bucket rate‑limiting algorithms, explaining their core principles, Java implementation details, key advantages and drawbacks, suitable application scenarios, interview‑style Q&A, and advanced hybrid strategies for building robust high‑concurrency systems.

JavaRate Limitingdistributed systems
0 likes · 9 min read
Token Bucket vs Leaky Bucket: Deep Dive into Core Traffic‑Control Algorithms
Tencent Cloud Middleware
Tencent Cloud Middleware
Mar 17, 2025 · Backend Development

Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation

This article explains why rate limiting is essential for high‑traffic microservices, outlines the key design considerations, compares major algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and details how Tencent Service Framework (TSF), Polaris, and TSF‑Consul implement distributed rate limiting with practical configuration examples and post‑limit handling strategies.

PolarisRate LimitingService Governance
0 likes · 23 min read
Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation
Tencent Cloud Developer
Tencent Cloud Developer
Jan 22, 2025 · Cloud Native

Rate Limiting: Concepts, Algorithms, and Distributed Solutions

Rate limiting protects micro‑service stability by rejecting excess traffic, using algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and can be deployed locally or distributed via Redis, load‑balancers, or coordination services, each offering different trade‑offs in precision, scalability, and complexity.

Rate Limitingalgorithmdistributed systems
0 likes · 31 min read
Rate Limiting: Concepts, Algorithms, and Distributed Solutions
Tencent Cloud Developer
Tencent Cloud Developer
Jan 15, 2025 · Operations

Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation

This article explains why rate limiting is essential for microservice reliability, outlines the key factors to consider before applying limits, compares major algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, describes post‑limit actions, and details how Tencent Service Framework (TSF) implements configurable, tag‑based rate limiting in cloud‑native environments.

Rate LimitingService Governancemicroservices
0 likes · 19 min read
Mastering Microservice Rate Limiting: Strategies, Algorithms, and TSF Implementation
Programmer XiaoFu
Programmer XiaoFu
Sep 26, 2024 · Backend Development

Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained

This article explains how Guava's RateLimiter, built on the token‑bucket algorithm, provides smooth burst handling, configurable rates, warm‑up support, and thread safety, and demonstrates its usage through detailed code examples and best‑practice recommendations for API, database, and crawler throttling.

ConcurrencyGuavaJava
0 likes · 9 min read
Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained
JavaEdge
JavaEdge
Aug 15, 2024 · Backend Development

How to Implement Rate Limiting in Event‑Driven Microservices with Resilience4j

This article explains how to use a token‑bucket rate limiter, such as the one provided by Resilience4j, to keep event‑driven microservices within the request/response API traffic limits, detailing the underlying problem, integration steps, code example, and practical considerations.

Rate LimitingResilience4jtoken bucket
0 likes · 7 min read
How to Implement Rate Limiting in Event‑Driven Microservices with Resilience4j
FunTester
FunTester
Mar 4, 2024 · Backend Development

How to Build a Simple Java Rate Limiter from Scratch

This article explains the concept and benefits of rate limiting, reviews popular Java libraries, and walks through a custom implementation using maps, locks, and atomic counters, complete with full source code and a test script demonstrating a 2‑requests‑per‑2‑seconds policy.

ConcurrencyJavaRate Limiting
0 likes · 9 min read
How to Build a Simple Java Rate Limiter from Scratch
FunTester
FunTester
Mar 4, 2024 · Backend Development

Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger

This article explains the purpose and benefits of rate limiting, reviews popular Java rate‑limiting libraries, and provides a step‑by‑step guide with complete source code for building a simple, thread‑safe custom rate limiter using maps, ReentrantLock, and AtomicInteger.

ConcurrencyJavaRate Limiting
0 likes · 9 min read
Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger
Tencent Cloud Developer
Tencent Cloud Developer
Feb 28, 2024 · Backend Development

Comprehensive Guide to Rate Limiting Algorithms and Distributed Rate Limiting Solutions

This guide explains why rate limiting is essential for micro‑service stability, outlines six design principles, details four classic algorithms—fixed window, sliding window, leaky bucket, and token bucket—and compares centralized Redis, load‑balancer cache, and coordination‑service distributed solutions.

Rate Limitingalgorithmdistributed systems
0 likes · 30 min read
Comprehensive Guide to Rate Limiting Algorithms and Distributed Rate Limiting Solutions
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 2, 2023 · Backend Development

Mastering Rate Limiting in Spring Boot: Token Bucket, Leaky Bucket, and Counter Techniques

An in‑depth guide explains three rate‑limiting algorithms—counter, leaky bucket, and token bucket—demonstrates their implementation in Spring Boot using Guava’s RateLimiter and Baidu’s ratelimiter‑spring‑boot‑starter, provides full Maven dependencies, configuration snippets, and Java code examples, and shows testing results.

GuavaSpring Bootbackend development
0 likes · 8 min read
Mastering Rate Limiting in Spring Boot: Token Bucket, Leaky Bucket, and Counter Techniques
Shepherd Advanced Notes
Shepherd Advanced Notes
Aug 21, 2023 · Backend Development

High‑Availability Rate‑Limiting Solutions for Spring Boot Systems

The article explains why rate limiting is essential for high‑traffic Spring Boot services, compares counter, sliding‑window, token‑bucket and leaky‑bucket algorithms, demonstrates implementations with plain Java, Guava RateLimiter, AOP, and distributed approaches using Redis‑Lua and Nginx‑Lua, and provides practical configuration examples.

GuavaNginxRate Limiting
0 likes · 20 min read
High‑Availability Rate‑Limiting Solutions for Spring Boot Systems
JD Retail Technology
JD Retail Technology
Aug 14, 2023 · Backend Development

In‑Depth Analysis of Guava RateLimiter: Token‑Bucket Algorithm, Code Structure, and Usage

This article explains why rate limiting is essential in high‑concurrency and transaction‑processing systems, introduces Google Guava's RateLimiter as a token‑bucket implementation, walks through its source code—including class hierarchy, core algorithms, and usage examples—and discusses practical considerations and extensibility.

GuavaJavaRate Limiting
0 likes · 19 min read
In‑Depth Analysis of Guava RateLimiter: Token‑Bucket Algorithm, Code Structure, and Usage
Selected Java Interview Questions
Selected Java Interview Questions
Jun 30, 2023 · Backend Development

Implementing Rate Limiting in Java with Guava, Custom Annotations, and Redis Lua Scripts

This article explains how to protect high‑concurrency Java applications using rate‑limiting techniques, covering basic algorithms such as counter, leaky‑bucket and token‑bucket, demonstrating a single‑node implementation with Guava’s RateLimiter and custom annotations, and showing a distributed solution based on Redis and Lua scripts.

GuavaJavaRate Limiting
0 likes · 15 min read
Implementing Rate Limiting in Java with Guava, Custom Annotations, and Redis Lua Scripts
AI Cyberspace
AI Cyberspace
Jun 13, 2023 · Operations

Master Linux Traffic Control: Practical TC Commands and QoS Strategies

This article explains Linux traffic control fundamentals, covering the three-layer processing model, queue types, token‑bucket mechanisms, kernel TC architecture, Qdisc/Class/Filter hierarchy, and provides step‑by‑step tc CLI examples for implementing QoS, DiffServ, and enterprise networking policies.

LinuxQoSnetwork
0 likes · 28 min read
Master Linux Traffic Control: Practical TC Commands and QoS Strategies
MaGe Linux Operations
MaGe Linux Operations
Mar 31, 2023 · Backend Development

Mastering Rate Limiting: Leaky Bucket, Token Bucket, and Sliding Window in Go

This article explains three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations to help developers choose and integrate the right strategy for handling traffic spikes and protecting backend resources.

BackendRate Limitingalgorithm
0 likes · 15 min read
Mastering Rate Limiting: Leaky Bucket, Token Bucket, and Sliding Window in Go
MaGe Linux Operations
MaGe Linux Operations
Mar 27, 2023 · Backend Development

Mastering Rate Limiting: Concepts, Algorithms, and Real-World Implementations

This article explains the fundamental concepts of rate limiting, including time and resource dimensions, various rule types such as QPS, connection count, bandwidth, black/white lists, and distributed considerations, then details common algorithms like token bucket, leaky bucket, sliding window, and practical implementations using Nginx, Guava, Redis, and Sentinel.

BackendRate Limitingdistributed systems
0 likes · 16 min read
Mastering Rate Limiting: Concepts, Algorithms, and Real-World Implementations
Architecture Digest
Architecture Digest
Mar 27, 2023 · Backend Development

Rate Limiting: Concepts, Algorithms, and Implementation Strategies

This article explains the fundamental concepts of rate limiting, compares popular algorithms such as token bucket, leaky bucket, and sliding window, and reviews practical implementation methods including Nginx, middleware, Redis, Guava, and Tomcat configurations for both single‑machine and distributed environments.

Rate Limitingleaky-bucketsliding window
0 likes · 17 min read
Rate Limiting: Concepts, Algorithms, and Implementation Strategies
Top Architect
Top Architect
Mar 26, 2023 · Backend Development

Comprehensive Guide to Rate Limiting: Concepts, Algorithms, and Implementation Strategies

This article provides a thorough overview of rate limiting, covering its basic concepts, common algorithms such as token bucket, leaky bucket and sliding window, and practical implementation methods across Nginx, Tomcat, Guava, Redis, Sentinel and other middleware for both single‑machine and distributed systems.

Rate LimitingRedismiddleware
0 likes · 17 min read
Comprehensive Guide to Rate Limiting: Concepts, Algorithms, and Implementation Strategies
ByteDance SYS Tech
ByteDance SYS Tech
Mar 23, 2023 · Backend Development

From Token Buckets to Carousel: Solving Rate Limiter Challenges in High‑Performance Networks

This article reviews the fundamentals of token‑bucket rate limiters, identifies precision, cascading compensation, and TCP‑loss sensitivity issues, and details two major improvements—port‑loan backpressure and the Carousel algorithm—while outlining future directions for more reliable network traffic shaping.

BackpressureDPDKRate Limiting
0 likes · 14 min read
From Token Buckets to Carousel: Solving Rate Limiter Challenges in High‑Performance Networks
Architect's Guide
Architect's Guide
Mar 21, 2023 · Backend Development

Fundamentals and Common Practices of Rate Limiting in Distributed Systems

This article explains the basic concepts, dimensions, and typical algorithms of rate limiting, discusses various implementation strategies such as token bucket, leaky bucket, and sliding window, and reviews practical solutions using Nginx, Guava, Redis, Sentinel, and Tomcat for both single‑node and distributed environments.

leaky-bucketsliding windowtoken bucket
0 likes · 16 min read
Fundamentals and Common Practices of Rate Limiting in Distributed Systems
Programmer DD
Programmer DD
Mar 16, 2023 · Backend Development

Mastering Rate Limiting with Redis: 3 Practical Implementations

This article explains three Redis‑based rate‑limiting techniques—using SETNX, sorted sets, and a token‑bucket with lists—providing code examples, discussing their advantages and drawbacks, and showing how to integrate them into Java Spring applications to protect high‑concurrency services.

BackendJavaRate Limiting
0 likes · 7 min read
Mastering Rate Limiting with Redis: 3 Practical Implementations
Top Architect
Top Architect
Mar 3, 2023 · Backend Development

Comprehensive Guide to Rate Limiting: Concepts, Algorithms, and Implementations

This article explains the principles and practical implementations of rate limiting in backend systems, covering real‑world scenarios, strategies such as circuit breaking, service degradation, delayed and privileged handling, common algorithms like counter, leaky‑bucket and token‑bucket, and code examples using Guava and Nginx + Lua.

Circuit BreakerRate Limitingtoken bucket
0 likes · 14 min read
Comprehensive Guide to Rate Limiting: Concepts, Algorithms, and Implementations
MaGe Linux Operations
MaGe Linux Operations
Feb 25, 2023 · Backend Development

Mastering Rate Limiting: Strategies, Algorithms, and Real‑World Implementations

This article explains how rate limiting protects system availability by controlling traffic flow, introduces common patterns such as circuit breaking, service degradation, delay and privilege handling, compares cache, degradation, and rate limiting, and details popular algorithms and practical code implementations for both single‑node and distributed environments.

Circuit BreakerGuavaRate Limiting
0 likes · 13 min read
Mastering Rate Limiting: Strategies, Algorithms, and Real‑World Implementations
vivo Internet Technology
vivo Internet Technology
Feb 15, 2023 · Artificial Intelligence

Optimizing CDN Bandwidth Utilization and Cost Reduction with Predictive Control (Yugong Platform)

By leveraging the Yugong Platform’s predictive control—combining Prophet‑based threshold forecasts, custom real‑time bandwidth models, and a token‑bucket mechanism—to smooth peaks and fill valleys, enterprises can dramatically improve CDN bandwidth utilization, automate adjustments, and substantially lower peak‑based billing costs.

CDNFlow ControlPredictive Modeling
0 likes · 23 min read
Optimizing CDN Bandwidth Utilization and Cost Reduction with Predictive Control (Yugong Platform)
Architect
Architect
Dec 10, 2022 · Backend Development

Rate Limiting: Concepts, Common Algorithms, and Practical Implementation Strategies

This article explains the fundamentals of rate limiting, describes widely used algorithms such as token bucket, leaky bucket, and sliding window, and details practical implementation methods ranging from single‑machine tools like Guava and Tomcat to distributed solutions using Nginx, Redis, and Sentinel.

Rate Limitingdistributed systemsleaky-bucket
0 likes · 17 min read
Rate Limiting: Concepts, Common Algorithms, and Practical Implementation Strategies
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Oct 20, 2022 · Backend Development

Implementing Rate Limiting in Spring Cloud Gateway Using Redis

This article explains how to configure distributed rate limiting in Spring Cloud Gateway by adding the reactive Redis dependency, setting up Redis connection properties, defining a RequestRateLimiter filter with token‑bucket parameters, implementing a custom KeyResolver, and demonstrating the behavior with HTTP 429 and 403 responses.

JavaRate LimitingSpring Cloud Gateway
0 likes · 12 min read
Implementing Rate Limiting in Spring Cloud Gateway Using Redis
Tencent Cloud Developer
Tencent Cloud Developer
Sep 6, 2022 · Backend Development

Understanding Rate Limiting in Distributed Systems: Algorithms and Best Practices

Rate limiting safeguards distributed systems by controlling request rates through algorithms such as leaky bucket, token bucket, fixed and sliding windows, and back pressure, while client‑side tactics like exponential backoff, jitter, and careful retries, and requires atomic distributed storage solutions (e.g., Redis+Lua) to avoid race conditions.

Rate LimitingSystem Designalgorithm
0 likes · 16 min read
Understanding Rate Limiting in Distributed Systems: Algorithms and Best Practices
Architecture Digest
Architecture Digest
Jul 22, 2022 · Backend Development

Understanding Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Java Implementations

This article explains the principle of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then delves into distributed rate‑limiting dimensions, common algorithms like token‑bucket and leaky‑bucket, and concrete implementations using Guava, Nginx, Redis and Lua with full code examples.

Distributed Rate LimitingNginxbackend development
0 likes · 21 min read
Understanding Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Java Implementations
IT Architects Alliance
IT Architects Alliance
May 24, 2022 · Backend Development

How to Ensure API Idempotency and Implement Distributed Rate Limiting in Java

This guide explains the principles of API idempotency using unique business IDs or token mechanisms, explores distributed rate‑limiting dimensions, compares token‑bucket and leaky‑bucket algorithms, and provides concrete implementations with Guava RateLimiter, Nginx configuration, and a Redis‑Lua script integrated into Spring Boot, including annotation‑based AOP for easy usage.

API idempotencyDistributed Rate LimitingGuava RateLimiter
0 likes · 19 min read
How to Ensure API Idempotency and Implement Distributed Rate Limiting in Java
Top Architect
Top Architect
May 23, 2022 · Backend Development

Idempotent Interfaces and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations

This article explains the importance of interface idempotency and presents a comprehensive guide to distributed rate limiting, covering key dimensions, token‑bucket and leaky‑bucket algorithms, and concrete implementations using Guava RateLimiter, Nginx, and Redis‑Lua with Java code examples.

Rate Limitingidempotencyleaky-bucket
0 likes · 19 min read
Idempotent Interfaces and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations
MaGe Linux Operations
MaGe Linux Operations
May 18, 2022 · Backend Development

Rate Limiting in Go: Leaky Bucket, Token Bucket, Sliding Window

This article explores three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations, enabling developers to choose and integrate the appropriate strategy for controlling request traffic without external dependencies.

BackendRate Limitingleaky-bucket
0 likes · 15 min read
Rate Limiting in Go: Leaky Bucket, Token Bucket, Sliding Window
Architecture Digest
Architecture Digest
Mar 4, 2022 · Backend Development

Idempotent API Design and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Nginx, and Redis+Lua

This article explains how to achieve interface idempotency using unique business IDs or token mechanisms and presents comprehensive distributed rate‑limiting techniques—including token‑bucket and leaky‑bucket algorithms, Nginx directives, Guava RateLimiter, and Redis‑Lua scripts—along with practical Spring Boot code examples.

LuaNginxRate Limiting
0 likes · 16 min read
Idempotent API Design and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Nginx, and Redis+Lua
IT Architects Alliance
IT Architects Alliance
Mar 1, 2022 · Backend Development

Interface Idempotency and Distributed Rate Limiting: Token Bucket, Leaky Bucket, Guava, Nginx, and Redis+Lua

This article explains the concept of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then dives into distributed rate‑limiting strategies covering dimensions, token‑bucket and leaky‑bucket algorithms, and concrete implementations using Guava RateLimiter, Nginx, and Redis‑Lua scripts.

Lualeaky-buckettoken bucket
0 likes · 18 min read
Interface Idempotency and Distributed Rate Limiting: Token Bucket, Leaky Bucket, Guava, Nginx, and Redis+Lua
Programmer DD
Programmer DD
Nov 10, 2021 · Backend Development

Master Redis Rate Limiting: SetNX, ZSet Sliding Window, and Token Bucket

This article explains three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.

JavaRate LimitingRedis
0 likes · 7 min read
Master Redis Rate Limiting: SetNX, ZSet Sliding Window, and Token Bucket
macrozheng
macrozheng
Oct 22, 2021 · Backend Development

Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP

This tutorial explains why API rate limiting is essential for high‑traffic Spring Boot services, introduces counter, leaky‑bucket, and token‑bucket algorithms, shows how to use Guava's RateLimiter, and demonstrates a clean custom‑annotation AOP solution to decouple rate‑limiting logic from business code.

AOPGuavaJava
0 likes · 13 min read
Mastering API Rate Limiting in Spring Boot: Algorithms, Guava & AOP
IT Architects Alliance
IT Architects Alliance
Oct 21, 2021 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Real‑World Implementations

This article explains why rate limiting is essential for system stability, compares circuit breaking, service degradation, delayed processing, and privileged handling, details counter, leaky‑bucket, and token‑bucket algorithms, and provides concrete Java, Guava, and Nginx‑Lua code examples for practical deployment.

Circuit BreakerGuavaJava
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Strategies, and Real‑World Implementations
Top Architect
Top Architect
Oct 14, 2021 · Cloud Native

Rate Limiting in Spring Cloud Gateway: Algorithms, Implementations, and Practical Guide

This article provides a comprehensive overview of rate‑limiting techniques for Spring Cloud Gateway, covering common scenarios, classic algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and practical implementations using Redis, Resilience4j, Bucket4j, Guava and custom local limiters.

RedisResilience4jSpring Cloud Gateway
0 likes · 41 min read
Rate Limiting in Spring Cloud Gateway: Algorithms, Implementations, and Practical Guide
Java High-Performance Architecture
Java High-Performance Architecture
Oct 2, 2021 · Backend Development

Mastering Rate Limiting: Strategies, Algorithms, and Real‑World Implementations

This article explains the concept of rate limiting through real‑world analogies, outlines common throttling strategies such as circuit breaking, service degradation, delayed and privileged processing, compares key algorithms like counter, leaky‑bucket and token‑bucket, and provides practical Guava, token‑bucket and Nginx‑Lua code examples for both single‑node and distributed systems.

Circuit BreakerGuavatoken bucket
0 likes · 15 min read
Mastering Rate Limiting: Strategies, Algorithms, and Real‑World Implementations
Java Interview Crash Guide
Java Interview Crash Guide
Sep 11, 2021 · Backend Development

Mastering Rate Limiting: Algorithms, Strategies, and Real-World Implementations

This article explains why rate limiting is essential, outlines common strategies such as circuit breaking, service degradation, delay processing, and privilege handling, compares counter, leaky‑bucket and token‑bucket algorithms, and provides practical Java and Nginx‑Lua implementation examples for backend systems.

Circuit BreakerRate Limitingconcurrency control
0 likes · 13 min read
Mastering Rate Limiting: Algorithms, Strategies, and Real-World Implementations
Programmer DD
Programmer DD
Aug 12, 2021 · Backend Development

How to Build a Simple Token Bucket RateLimiter in Java

This article provides an overview of the token bucket algorithm, demonstrates a straightforward Java implementation of a RateLimiter with code examples, compares it to Guava's RateLimiter internals, and includes diagrams and test results to illustrate its behavior.

ConcurrencyGuavaJava
0 likes · 4 min read
How to Build a Simple Token Bucket RateLimiter in Java
Java Interview Crash Guide
Java Interview Crash Guide
Jul 24, 2021 · Backend Development

Mastering Rate Limiting in Go: Algorithms, Implementations, and Best Practices

This article explains why rate limiting is essential for high‑availability services, describes HTTP 429 standards and response headers, classifies rate‑limiting strategies by granularity, target, and algorithm, and provides detailed Go code examples using the time/rate library for fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket implementations.

BackendGoRate Limiting
0 likes · 28 min read
Mastering Rate Limiting in Go: Algorithms, Implementations, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 15, 2021 · Backend Development

Understanding Rate Limiting: Counter, Sliding Window, Leaky Bucket, and Token Bucket Algorithms

The article introduces the concept of rate limiting, explains why it is needed both offline (e.g., crowded theme parks) and online (e.g., flash sales), and details four common algorithms—counter, sliding window, leaky bucket, and token bucket—along with their implementation considerations and trade‑offs.

Rate Limitingcounter algorithmleaky-bucket
0 likes · 9 min read
Understanding Rate Limiting: Counter, Sliding Window, Leaky Bucket, and Token Bucket Algorithms
360 Smart Cloud
360 Smart Cloud
Apr 30, 2021 · Backend Development

Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation

This article explains what rate limiting is, why it is needed, the typical actions taken when limits are reached, compares single‑node and distributed architectures, reviews four classic limiting algorithms, and provides a practical Redis‑Lua token‑bucket implementation with code examples.

BackendRate Limitingalgorithm
0 likes · 14 min read
Understanding Rate Limiting: Concepts, Architectures, Algorithms, and a Redis‑Lua Token Bucket Implementation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 26, 2021 · Backend Development

Rate Limiting in Spring Boot: Counter, Leaky & Token Buckets using Guava & Baidu

This article explains three classic rate‑limiting algorithms—counter, leaky bucket, and token bucket—illustrates their principles, compares their behavior, and provides practical Spring Boot implementations using Google Guava’s RateLimiter and Baidu’s ratelimiter‑spring‑boot‑starter, including configuration, code samples, and performance testing.

BackendGuavaJava
0 likes · 10 min read
Rate Limiting in Spring Boot: Counter, Leaky & Token Buckets using Guava & Baidu
Top Architect
Top Architect
Feb 14, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation

This article explains the fundamentals of rate limiting, its importance for high‑availability services, various classification dimensions, common algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, and demonstrates practical usage with Go's golang.org/x/time/rate library including code examples and configuration tips.

Rate Limitingalgorithmdistributed systems
0 likes · 26 min read
An Introduction to Rate Limiting: Concepts, Classifications, and Go Implementation
Code Ape Tech Column
Code Ape Tech Column
Jan 27, 2021 · Backend Development

An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation

This article introduces rate limiting, explains its purpose and classifications, compares fixed and sliding windows, describes common algorithms such as token bucket, leaky bucket, and counter, and provides detailed Go code examples using the golang.org/x/time/rate library for practical implementation.

Rate Limitinggolangleaky-bucket
0 likes · 25 min read
An Introduction to Rate Limiting: Concepts, Classifications, Algorithms, and Go Implementation
Java Architect Essentials
Java Architect Essentials
Oct 5, 2020 · Backend Development

Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script

This article explains how Spring Cloud Gateway uses a token‑bucket algorithm backed by Redis and a Lua script to perform distributed rate limiting, reviews common limiting algorithms, provides detailed Java and Lua code examples, and analyzes each step of the implementation for high‑concurrency systems.

LuaRate LimitingSpring Cloud Gateway
0 likes · 7 min read
Implementing Distributed Rate Limiting in Spring Cloud Gateway with Token Bucket and Lua Script
Aikesheng Open Source Community
Aikesheng Open Source Community
Sep 17, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example

This article explains the principles of leaky‑bucket and token‑bucket rate‑limiting algorithms, compares their behavior in high‑concurrency e‑commerce scenarios, and provides a complete Python implementation to illustrate how token‑bucket can handle burst traffic while maintaining system stability.

High ConcurrencyPythonRate Limiting
0 likes · 7 min read
Understanding Rate Limiting: Leaky Bucket and Token Bucket Algorithms with a Python Example
JD Retail Technology
JD Retail Technology
May 25, 2020 · Backend Development

Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms

This article explains the fundamentals of rate limiting for high‑concurrency systems, covering why it is needed, the conditions that trigger it, and detailed introductions to the three main algorithms—counter (fixed and sliding windows), leaky bucket, and token bucket—along with their advantages, drawbacks, and sample pseudo‑code implementations.

BackendRate Limitingcounter algorithm
0 likes · 13 min read
Understanding Rate Limiting: Counter, Leaky Bucket, and Token Bucket Algorithms
Architecture Digest
Architecture Digest
Apr 14, 2020 · Operations

Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples

This article explains the principles of token‑bucket and leaky‑bucket rate‑limiting algorithms, shows how Nginx implements them with the limit_req and limit_conn modules, and provides detailed configuration examples—including burst, nodelay, and custom status codes—to control request rates and concurrent connections.

Rate Limitingleaky-bucketlimit_conn
0 likes · 12 min read
Nginx Rate Limiting: Token‑Bucket, Leaky‑Bucket Algorithms and Configuration Examples
macrozheng
macrozheng
Mar 25, 2020 · Backend Development

Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems

This article explains how to implement token‑bucket rate limiting with Guava's RateLimiter, compare it to leaky‑bucket algorithms, and combine it with optimistic and pessimistic locking techniques to prevent overselling in high‑concurrency flash‑sale applications.

JavaOptimistic LockPessimistic Lock
0 likes · 15 min read
Mastering Token Bucket Rate Limiting and Lock Strategies in Flash Sale Systems
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 22, 2020 · Backend Development

Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter

The article explains the principles of traffic shaping through leaky‑bucket and token‑bucket algorithms, details how Google Guava's RateLimiter implements token‑bucket rate limiting, and provides Java code examples illustrating token generation, acquisition, and practical usage in high‑concurrency backend systems.

BackendGuavaJava
0 likes · 10 min read
Understanding Rate Limiting: Leaky Bucket, Token Bucket, and Guava RateLimiter
Programmer DD
Programmer DD
Dec 22, 2019 · Operations

Master nftables: Build a Simple Linux Firewall with Token Bucket Rate Limiting

This guide walks you through installing nftables on CentOS 7, creating a basic firewall with INPUT, FORWARD, and OUTPUT chains, leveraging built‑in sets and maps for efficient IP and port matching, implementing connection‑tracking, token‑bucket rate limiting for ICMP, handling TCP/UDP traffic, persisting rules, and configuring rsyslog logging.

connection trackingfirewalliptables alternative
0 likes · 17 min read
Master nftables: Build a Simple Linux Firewall with Token Bucket Rate Limiting
21CTO
21CTO
Oct 31, 2019 · Backend Development

Master Distributed Rate Limiting with Token Buckets, Redis, and Code

This article explains why rate limiting is essential for microservice stability, compares leaky‑bucket and token‑bucket algorithms, shows how to implement local and distributed throttling with Java's AtomicLong, Redis, and a control‑server architecture, and points to an open‑source project for practical use.

JavaRate LimitingRedis
0 likes · 9 min read
Master Distributed Rate Limiting with Token Buckets, Redis, and Code
Didi Tech
Didi Tech
May 17, 2019 · Databases

Ceph Distributed Storage System – Architecture, IO Processes, Heartbeat, Communication Framework, CRUSH Algorithm, and Custom QoS

The article comprehensively explains Ceph’s distributed storage architecture—including monitors, OSDs, MDS, and RADOS—its block, file, and object services, its detailed I/O and heartbeat processes, the publish/subscribe communication framework, the deterministic CRUSH placement algorithm, and a token‑bucket based custom QoS for RBD.

CRUSH algorithmCephIO Flow
0 likes · 22 min read
Ceph Distributed Storage System – Architecture, IO Processes, Heartbeat, Communication Framework, CRUSH Algorithm, and Custom QoS
Java Backend Technology
Java Backend Technology
Dec 12, 2018 · Backend Development

Mastering Rate Limiting: Strategies, Best Practices, and Implementation Guide

This comprehensive guide explains the differences between rate limiting and circuit breaking, outlines how to determine system capacity, details four core throttling strategies (fixed window, sliding window, leaky bucket, token bucket), and offers practical best‑practice recommendations for distributed backend systems.

BackendRate Limitingleaky-bucket
0 likes · 14 min read
Mastering Rate Limiting: Strategies, Best Practices, and Implementation Guide
Java Captain
Java Captain
Sep 1, 2018 · Backend Development

Thoughts on High‑Concurrency Traffic Control and Rate‑Limiting Techniques

This article shares practical insights on handling high‑concurrency traffic, explaining what constitutes large traffic, common mitigation strategies such as caching, downgrade, and focusing on rate‑limiting techniques—including counters, sliding windows, leaky‑bucket and token‑bucket algorithms—and demonstrates using Guava’s RateLimiter for Java applications.

Backend PerformanceGuavaHigh Concurrency
0 likes · 6 min read
Thoughts on High‑Concurrency Traffic Control and Rate‑Limiting Techniques
dbaplus Community
dbaplus Community
Jun 25, 2018 · Backend Development

Mastering Rate Limiting for High‑Traffic Flash‑Sale Systems

This article explains why rate limiting is essential for flash‑sale (seckill) systems, compares token‑bucket and leaky‑bucket algorithms, and provides concrete Tomcat, Nginx, OpenResty, and Guava configurations along with code snippets and load‑testing results to help engineers implement robust throttling.

NginxRate LimitingTomcat
0 likes · 14 min read
Mastering Rate Limiting for High‑Traffic Flash‑Sale Systems
Java Backend Technology
Java Backend Technology
Jun 21, 2018 · Backend Development

Mastering Rate Limiting for High‑Traffic Flash Sale Systems

This article explains why rate limiting is essential for flash‑sale (seckill) services, compares token‑bucket and leaky‑bucket algorithms, and provides practical configuration examples for Tomcat, Nginx, and OpenResty, along with testing methods and code snippets.

Load TestingNginxRate Limiting
0 likes · 14 min read
Mastering Rate Limiting for High‑Traffic Flash Sale Systems
21CTO
21CTO
Jun 16, 2018 · Backend Development

Master Rate Limiting: Token & Leaky Buckets, Tomcat, Nginx & OpenResty

This article explains why high‑traffic scenarios like flash‑sale systems need rate limiting, compares token‑bucket and leaky‑bucket algorithms, and shows practical configurations for Tomcat, Nginx, and OpenResty to protect APIs and ensure system stability.

NginxRate LimitingTomcat
0 likes · 10 min read
Master Rate Limiting: Token & Leaky Buckets, Tomcat, Nginx & OpenResty
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 18, 2018 · Backend Development

Rate Limiting Demystified: Token Bucket, Leaky Bucket & Counter Algorithms in Java

During high‑traffic scenarios, services can become unavailable, so implementing rate‑limiting techniques like token bucket, leaky bucket, and counter algorithms—illustrated with Java code examples using Guava RateLimiter, AtomicInteger, and Semaphore—helps smooth bursts, control concurrency, and prevent system overload.

GuavaRate Limitingcounter algorithm
0 likes · 6 min read
Rate Limiting Demystified: Token Bucket, Leaky Bucket & Counter Algorithms in Java
Architecture Digest
Architecture Digest
Apr 23, 2018 · Backend Development

Designing High‑Concurrency Architecture: Principles, Idempotency, Rate Limiting and a Token‑Bucket Demo

The article explains how to design a backend architecture that can handle millions of concurrent requests by applying principles such as service decomposition, high availability, idempotent business logic, and various rate‑limiting algorithms—including sliding window, leaky bucket and token bucket—with a runnable Java demo.

High ConcurrencyRate Limitingbackend architecture
0 likes · 11 min read
Designing High‑Concurrency Architecture: Principles, Idempotency, Rate Limiting and a Token‑Bucket Demo
Architecture Digest
Architecture Digest
Feb 12, 2018 · Backend Development

Handling High Traffic: Common Rate‑Limiting Techniques and Guava RateLimiter

This article discusses the definition of high traffic, common mitigation methods such as caching, degradation, and especially various rate‑limiting algorithms—including counters, sliding windows, leaky bucket, and token bucket—and demonstrates using Guava's RateLimiter for practical throttling.

Backend PerformanceGuavaHigh Concurrency
0 likes · 7 min read
Handling High Traffic: Common Rate‑Limiting Techniques and Guava RateLimiter