Tagged articles
Long Polling
50 articles · Page 1 of 1
This article deep-dives into Nacos' dual role as service registry and config center, explaining its AP-based Distro protocol, heartbeat mechanisms, gRPC long-polling config push, @RefreshScope internals, deployment essentials, and eight common pitfalls with troubleshooting steps.
@RefreshScopeConfiguration CenterDistro Protocol
0 likes · 24 min read

This article dissects Nacos configuration center's core mechanisms — long-connection push, local disk caching, and differentiated refresh behaviors — and postmortems four real production incidents: config drift causing instance divergence, large-config push triggering cluster avalanche, K8s IP-based gray release failure, and rollback ineffectiveness due to lost push events and cache pollution. It provides coding standards, enterprise-grade landing specifications, and emergency SOPs.
CachingConfiguration CenterGray Release
0 likes · 15 min read

This article explains how RocketMQ’s consumer model is fundamentally pull‑based with a long‑polling optimization that provides a push‑like experience, covering interview focus points, detailed mechanism, code examples, best practices, and common misconceptions.
BackendConsumer ModelJava
0 likes · 8 min read

This article compares four real‑time communication techniques—short polling, long polling, WebSocket, and Server‑Sent Events—detailing their protocols, advantages, disadvantages, latency, resource consumption, and typical use cases, and provides guidance on selecting the most suitable method for different application requirements.
Long PollingSSEbackend development
0 likes · 6 min read

This article explains Nacos Config Center's long‑polling mechanism, detailing both client‑side scheduling and server‑side handling, with code walkthroughs, architecture diagrams, and the flow of configuration change detection and notification.
Configuration ManagementJavaLong Polling
0 likes · 18 min read

This article explains the inner workings of Nacos' configuration center, detailing the client‑side long‑polling mechanism, the server‑side handling of listener requests, and the key classes and code paths that enable real‑time config updates in microservice environments.
BackendConfiguration CenterJava
0 likes · 13 min read

This article compares three classic real‑time web technologies—Server‑Sent Events, WebSocket, and Long Polling—explaining their principles, Spring Boot implementations, advantages, disadvantages, and suitable scenarios to help developers select the optimal solution for live data updates.
BackendLong PollingReal-time
0 likes · 6 min read

This article explains how RocketMQ implements long‑polling for message consumption, detailing the pull‑based model, the broker and consumer timeout settings, the internal suspension of pull requests, and the processing loop that resumes suspended requests to improve efficiency.
BackendConsumerJava
0 likes · 7 min read

This article compares four real‑time communication techniques—short polling, long polling, WebSocket, and Server‑Sent Events—detailing their advantages, drawbacks, latency, resource consumption, and ideal use cases to help developers choose the most suitable solution for their applications.
Long PollingSSEbackend development
0 likes · 7 min read

The article walks through the need for a service registry in a micro‑service scenario, explains how services register and discover each other, discusses high‑availability deployment, and compares push, pull, and long‑polling mechanisms for dynamic detection of service instances.
High AvailabilityLong PollingService Discovery
0 likes · 10 min read


ITPUBDec 14, 2024 · Backend Development
This article explains why traditional HTTP cannot let servers initiate messages, compares periodic HTTP polling and long polling as workarounds, and introduces the full‑duplex WebSocket protocol—including its handshake, frame format, and typical use cases such as web games and real‑time chat.
HTTPLong PollingServer Push
0 likes · 15 min read

This article explains how Nacos’s ConfigService initiates a long‑polling task on the client side, how the client periodically checks for configuration changes, and how the Nacos server processes long‑polling requests, detailing the relevant classes, methods, and code flow.
Configuration CenterJavaLong Polling
0 likes · 14 min read

This article dissects Nacos' configuration center long‑polling mechanism, detailing the client‑side initialization, thread‑pool scheduling, cache handling, and server‑side request processing, while illustrating the flow with code snippets and diagrams to help developers understand real‑time config synchronization.
Configuration CenterJavaLong Polling
0 likes · 15 min read

This article explains the principles and source‑code flow of Nacos configuration center’s long‑polling mechanism, detailing how the client initiates periodic tasks, how the server processes listener requests, and how configuration changes are detected and propagated through various internal classes and threads.
BackendConfiguration CenterJava
0 likes · 10 min read


JavaEdgeJun 10, 2024 · Backend Development
This article walks through Nacos's LongPollingService source code, showing how it extracts headers, calculates timeouts, detects configuration changes, enforces connection limits, and uses Servlet 3.0 AsyncContext to handle long‑polling without blocking threads.
AsyncContextJavaLong Polling
0 likes · 6 min read

This article walks through six practical web‑push techniques—including short polling, long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—explaining their principles, trade‑offs, and providing complete Spring Boot and JavaScript code samples to help developers implement real‑time notification badges.
JavaLong PollingServer-Sent Events
0 likes · 18 min read

This article explains the inner workings of Nacos' long‑polling mechanism, covering both client‑side scheduling and server‑side handling, with detailed code walkthroughs, architectural diagrams, and insights into how configuration changes are detected and propagated in a distributed system.
Configuration CenterJavaLong Polling
0 likes · 17 min read

This article provides a detailed walkthrough of Nacos' configuration center long‑polling mechanism, explaining how the client initializes ConfigService, schedules periodic checks, processes configuration changes, and how the server receives listener requests, manages long‑polling tasks, and triggers change events, all illustrated with code snippets and diagrams.
BackendConfigurationJava
0 likes · 12 min read

This article explains various web message‑push techniques—including short and long polling, iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides detailed Java and JavaScript code samples, compares their trade‑offs, and shows how to integrate them in a Spring Boot application.
JavaJavaScriptLong Polling
0 likes · 19 min read


政采云技术Nov 9, 2023 · Backend Development
This article explains RocketMQ's core components, the differences between push and pull consumption modes, and how the framework implements a pseudo‑push mechanism using long polling, including detailed code analysis of the consumer and broker side processes.
BackendJavaLong Polling
0 likes · 19 min read

This article explores Apollo’s distributed configuration center, focusing on its core architecture and the implementation of HTTP Long Polling, including code examples, timeout considerations, and strategies to ensure reliable message delivery across multiple client nodes.
ApolloConfiguration CenterLong Polling
0 likes · 12 min read

The article explains Apollo’s client‑side long‑polling workflow, how the Config Service suspends requests with Spring DeferredResult, stores them in a cache, and notifies clients of configuration changes via database messages and background scanning, enabling immediate config refresh.
ApolloConfiguration ManagementLong Polling
0 likes · 3 min read

This article walks through multiple ways to add real‑time in‑site notifications—such as the familiar red‑dot badge—to a web application, covering short and long polling, iframe streaming, Server‑Sent Events, MQTT and WebSocket, with complete Spring Boot code examples and client‑side snippets.
Long PollingMQTTSSE
0 likes · 19 min read

This article details the design and optimization of a high‑throughput live‑streaming danmaku system, covering background requirements, bandwidth challenges, short‑polling versus WebSocket delivery, compression and frequency controls, service splitting with caching and lock‑free ring buffers, and reports successful handling of 700 k concurrent users during a major event.
Long Pollingbackend architecturedanmaku
0 likes · 13 min read

This article provides a comprehensive walkthrough of RocketMQ 4.9.x consumption architecture, covering the four core roles, publish‑subscribe model, storage structures, load‑balancing, long‑polling, concurrent and ordered consumption flows, progress persistence, and retry mechanisms, with illustrative diagrams and code snippets.
ConsumerLong PollingMessage Queue
0 likes · 28 min read

This article examines the false empty response issue caused by long‑polling coupling in RocketMQ 5.0 SimpleConsumer, analyzes existing approaches, and presents an adaptive, stateless proxy solution that decouples client and broker polls, adds notification, and includes metrics and configuration guidance.
Long PollingProxyRocketMQ
0 likes · 11 min read

The guide walks through building a real‑time instant‑messaging system—using a multiplayer monster‑battle demo—to compare polling, long‑polling, SSE and WebSocket, explains the WebSocket handshake and frame format, shows a custom Node.js server implementation, and advises adopting mature IM SDKs for production.
Long PollingNode.jsSSE
0 likes · 23 min read

Explore how long polling and Server‑Sent Events enable real‑time data exchange in front‑end development, comparing their principles, advantages, drawbacks, and providing practical JavaScript examples to help you choose the optimal technique for your application.
Frontend DevelopmentJavaScriptLong Polling
0 likes · 5 min read

This article compares short polling, long polling, WebSocket, and Server‑Sent Events, explaining their mechanisms, advantages, drawbacks, and appropriate use cases, and provides practical code examples for implementing each method in modern frontend development.
Long PollingPollingReal-time
0 likes · 13 min read

This article details the design, bandwidth optimization, and reliability strategies of a custom bullet‑chat system for Southeast Asian live streaming, covering background challenges, problem analysis, compression, request throttling, long‑polling versus WebSocket trade‑offs, and a short‑polling solution that successfully supported 700 k concurrent users.
BackendLong PollingWebSocket
0 likes · 10 min read

This article describes the design, challenges, and optimization strategies of a custom live‑streaming danmaku system for Southeast Asian markets, covering bandwidth constraints, latency issues, long‑polling versus WebSocket approaches, service splitting, caching, and a ring‑buffer implementation that supported 700 k concurrent users during a major sales event.
BackendLong PollingWebSocket
0 likes · 11 min read

This article presents a detailed case study of designing a high‑throughput danmu (bullet‑screen) system for Southeast Asian live streaming, analyzing bandwidth constraints, latency issues, and evaluating long‑polling, WebSocket, and short‑polling approaches, ultimately describing the chosen short‑polling solution, service partitioning, caching, and ring‑buffer techniques to achieve stable performance for millions of concurrent users.
Long PollingReal-time MessagingWebSocket
0 likes · 12 min read

This article explains RocketMQ's push and pull consumption modes, shows how its pseudo‑push implementation uses long polling to balance real‑time delivery and consumer pressure, and walks through the core source‑code mechanisms that hold and resume pull requests.
BackendLong PollingRocketMQ
0 likes · 10 min read

This article explains several server‑side techniques for real‑time web message push—including short and long polling, hidden‑iframe streaming, Server‑Sent Events, MQTT, and WebSocket—provides their principles, advantages, drawbacks, and complete Spring Boot/Java code examples for each approach.
JavaLong PollingSSE
0 likes · 17 min read

This article explains how Nacos configuration center works, clarifies that it uses a client‑initiated pull (long‑polling) model rather than push, and walks through key client and server source code components—including cacheMap, listeners, long‑polling handling, and configuration change notification – to help developers and interviewees master its internals.
Configuration CenterJavaLong Polling
0 likes · 17 min read

This article explains the internal long‑polling mechanism of Nacos configuration center used in Spring Cloud Alibaba, covering client‑side initialization, thread‑pool scheduling, request handling, server‑side processing, event listening, and code snippets that illustrate how configuration changes are detected and propagated.
Config ServiceJavaLong Polling
0 likes · 13 min read

This article explains how to design a service registry that enables service registration, discovery, high availability, and dynamic handling of service instances in a microservice architecture, covering registration methods, consumer/provider interaction, push/pull mechanisms, long‑polling, and heartbeat health checks.
High AvailabilityLong PollingPush‑Pull
0 likes · 8 min read

This article explains Nacos configuration center’s pull‑based data exchange, detailing the push vs pull models, long‑polling mechanism, core concepts like dataId, group, namespace, and provides in‑depth Java source‑code analysis of both client and server implementations.
Configuration CenterJavaLong Polling
0 likes · 16 min read

This article introduces Tencent Cloud Message Queue (CMQ), explains its underlying architecture and reliability mechanisms, compares it with Kafka and RabbitMQ, and demonstrates several practical scenarios such as broadcast‑pull model, long‑polling, delayed messages, message rewind, topic routing, large‑message handling, and encryption, accompanied by Python SDK code examples.
CMQLong PollingMessage Encryption
0 likes · 11 min read

This article explains the principles of long polling used by configuration centers like Nacos and Apollo, compares it with traditional polling and push models, and provides a complete Java demo showing client and server implementations for dynamic configuration updates.
ApolloConfiguration CenterJava
0 likes · 17 min read

This article explains the limits of HTTP keep-alive, compares Ajax polling and long‑polling techniques for server push, and then details how the WebSocket protocol establishes a full‑duplex connection through a handshake and data‑transfer phase.
AJAXHTTPKeep-Alive
0 likes · 7 min read


21CTOFeb 14, 2020 · Backend Development
This article explains the technical workflow of QR code login, covering the generation of UUIDs, QR images, server‑side Redis storage, mobile‑side token verification, long‑polling mechanisms, and the concrete implementations used by WeChat and Taobao, providing a complete reference for developers building similar authentication features.
Long PollingQR LoginRedis
0 likes · 16 min read


政采云技术Nov 20, 2019 · Frontend Development
This article explains the limitations of short and long polling, introduces the WebSocket protocol and its handshake mechanism, and provides complete client‑side and Node.js server code to build a basic real‑time chat application with heartbeat keep‑alive support.
Long PollingNode.jsPolling
0 likes · 11 min read

This article examines the limitations of Spring Cloud Config—especially Git‑based permission control and coarse granularity—explains why a database‑backed configuration center is preferable, and details a custom long‑polling refresh mechanism built with Spring's DeferredResult and asynchronous servlets.
Configuration CenterLong PollingSpring Boot
0 likes · 10 min read


21CTOMar 18, 2019 · Frontend Development
This article reviews the evolution of web real‑time push techniques—polling, long‑polling, iframe streaming—and explains why WebSocket offers superior bidirectional communication, lower latency, and reduced bandwidth, while providing practical code examples for each method.
Long PollingPollingWebSocket
0 likes · 12 min read

This article walks through setting up Nacos for dynamic configuration, covering server installation, compiling from source, starting the service, creating and modifying configuration items, and explaining the client’s long‑polling mechanism that pulls updates and triggers listeners, with detailed code snippets and diagrams.
Config ServiceDynamic ConfigurationLong Polling
0 likes · 14 min read

This article compares common web push techniques—including short polling, long polling, iframe streaming, WebSocket, and Server‑Sent Events—examining their principles, advantages, and drawbacks, and presents a practical selection and implementation case for real‑time order notifications in a client‑server application.
Long PollingServer-Sent EventsWebSocket
0 likes · 10 min read

This article explains the Pull mode of Pushlets, detailing its protocol steps, server-side session and queue management, client interactions, key configuration parameters, and the encapsulation of Pushlets into a Channel service for scalable backend message pushing.
Long PollingMessage QueuePull Mode
0 likes · 7 min read

This article examines server‑push technologies such as Comet, comparing plugin‑based socket approaches with HTTP long‑connection methods like AJAX long‑polling and iframe/htmlfile streaming, and provides practical guidance on building robust Comet applications using frameworks such as Pushlet.
COMETHTTPLong Polling
0 likes · 19 min read

This article explains the Pull mode of Pushlets, detailing its protocol, server‑side session management, client interactions, key configuration parameters, and the encapsulated Channel API that enables long‑connection message pushing for browsers and Java clients.
BackendLong PollingPull Mode
0 likes · 5 min read
