Tagged articles
request merging
20 articles · Page 1 of 1
This article explores how merging similar requests upstream can dramatically reduce downstream load, detailing Hystrix Collapser usage and configuration, a custom BatchCollapser implementation with time‑ and count‑based triggers, and the thread‑safe ConcurrentHashMultiset for high‑duplicate statistical scenarios.
BatchCollapserConcurrentHashMultisetHystrix
0 likes · 13 min read

By merging similar or duplicate requests upstream before sending them downstream, you can dramatically reduce downstream load and boost overall throughput; this article compares Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset, detailing their implementations, configurations, and ideal use cases.
BackendBatchCollapserConcurrentHashMultiset
0 likes · 15 min read

This article explains how to merge concurrent user requests into a single batch SQL query using Java's LinkedBlockingQueue, ScheduledThreadPoolExecutor and CompletableFuture in a Spring Boot application, thereby saving database connections and improving performance under high concurrency.
Spring Bootbatch processingdatabase optimization
0 likes · 13 min read

This article explains how to merge multiple user‑detail requests into a single database query using a blocking queue, scheduled thread pool, and CompletableFuture in Spring Boot, providing code examples, a high‑concurrency test, and discussion of trade‑offs such as added latency and timeout handling.
CompletableFutureConcurrencyJava
0 likes · 13 min read

This article explains how to batch multiple user‑info requests on the server side, merge them into a single SQL query using a blocking queue and ScheduledThreadPoolExecutor, and return the results individually, thereby reducing database connection usage and improving performance under high concurrency.
CompletableFutureJava ConcurrencySpring Boot
0 likes · 13 min read

This article explains how to combine multiple simultaneous user requests on the server side using a queue, scheduled thread pool and CompletableFuture in Spring Boot, reducing database connections while handling high concurrency, and discusses implementation details, testing, and potential pitfalls.
ConcurrencySpring Bootbatch processing
0 likes · 15 min read

singleflight, a Go concurrency primitive from the x/sync package, merges duplicate in‑flight requests to reduce server load, with detailed usage examples, source code analysis, and discussion of its differences from sync.Once and typical application scenarios such as cache‑penetration, remote calls, and task deduplication.
CacheConcurrencyGo
0 likes · 26 min read

This article explains how to combine duplicate API calls, ensure only the latest request result is displayed, and control concurrent request limits in JavaScript/React applications, providing practical code examples and execution flow analysis.
JavaScriptfrontendrequest merging
0 likes · 14 min read

This article explains the concept of request merging for high‑concurrency web services, outlines its advantages and drawbacks, and provides a complete Java implementation using ScheduledExecutorService, a memory queue, and a generic BatchCollapser utility with usage examples.
BackendJavaScheduledExecutorService
0 likes · 8 min read

This article explains how to merge multiple user requests on the server side, batch them into a single SQL query using a blocking queue and CompletableFuture, and handle high‑concurrency scenarios with scheduled tasks and timeout‑aware queues to save database connection resources.
ConcurrencyJavaQueue
0 likes · 13 min read

This article explains how to combine multiple user queries into a single database request using a queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, demonstrating code implementations, handling Java 8 CompletableFuture timeout limitations, and showing performance gains through request merging under high concurrency.
ConcurrencyJavaSpring Boot
0 likes · 15 min read

This article explains how to merge multiple backend requests in a SpringBoot application using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture to batch database queries, reduce connection overhead, handle high concurrency, and includes full Java code examples and performance testing.
Java ConcurrencySpringBootbackend optimization
0 likes · 15 min read

This article explains the concept, advantages, and drawbacks of request merging, and provides a complete Java implementation using ScheduledExecutorService, a memory queue, and generic batch handling interfaces, along with usage examples and sample code.
BackendConcurrencyJava
0 likes · 8 min read

This article demonstrates how to merge multiple user‑info requests on the server side using a blocking queue, ScheduledThreadPoolExecutor, and CompletableFuture in Spring Boot, thereby consolidating SQL queries into a single batch call to save database connection resources while handling high concurrency.
CompletableFutureJava ConcurrencyLinkedBlockingQueue
0 likes · 13 min read

This article explains how to merge multiple user‑detail requests on the server side using a blocking queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby converting many individual SQL calls into a single batch query, saving database connections and improving high‑concurrency performance.
CompletableFutureConcurrencyJava
0 likes · 13 min read

The article explains how to merge multiple user queries into a single batch request using a queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby reducing database connections and improving resource utilization while handling high‑concurrency scenarios.
CompletableFutureConcurrencyJava
0 likes · 13 min read


21CTOJun 18, 2021 · Frontend Development
This article presents a series of experiments comparing HTTP/1.1 and HTTP/2 request merging versus splitting, analyzing how concurrency, multiplexing, and header compression affect page load times for small images, large assets, and JavaScript under various network conditions.
ConcurrencyHTTP/2Web Performance
0 likes · 15 min read

By introducing request merging and batch APIs, this article demonstrates how to improve high‑concurrency performance in Java backend services, detailing the design, data structures, scheduled execution, and code implementation while discussing trade‑offs and practical considerations.
Java Concurrencybatch APIhigh concurrency
0 likes · 8 min read


21CTOMay 8, 2017 · Backend Development
This article explains how Facebook Live handles millions of concurrent streams and viewers by using a multi‑layer edge cache system, request merging, and load balancing to achieve high‑availability, low‑latency video delivery at massive scale.
Facebook Liveedge cacheload-balancing
0 likes · 7 min read

Facebook Live must support millions of concurrent streams and viewers, so its architecture uses a multi‑layer edge‑cache system, request merging, and load balancing to filter traffic, reduce streaming server load, and prevent request leakage, ensuring high performance during traffic spikes.
edge cachelive streamingload-balancing
0 likes · 7 min read
