BestHub
Sign in
Tagged articles
47 articles
Page 1 of 1
vivo Internet Technology
vivo Internet Technology
Dec 3, 2025 · Mobile Development

How Parallel Loading Supercharges H5 Instant SDK: Challenges, Early Designs, and Optimized Solutions

This article explains the parallel loading technique used in the H5 instant SDK to accelerate page startup, details the three resource‑handoff scenarios that cause synchronization challenges, reviews the early simple design and its drawbacks, and presents an optimized producer‑consumer model with fair locks and bridge streams to eliminate wasteful waiting and memory consumption.

H5 instant SDKJava concurrencyParallel Loading
0 likes · 31 min read
How Parallel Loading Supercharges H5 Instant SDK: Challenges, Early Designs, and Optimized Solutions
Python Programming Learning Circle
Python Programming Learning Circle
Sep 6, 2025 · Fundamentals

Stop Reinventing the Wheel: Use Python’s Built‑In Queue for Fast, Thread‑Safe Tasks

Python developers often create simple queues with lists using append and pop(0), but this approach has O(n) complexity and thread‑safety issues; the article explains how the built‑in queue module provides efficient, thread‑safe FIFO, LIFO, and priority queues, with code examples for single‑thread and multithreaded task processing.

Producer ConsumerPythonQueue
0 likes · 5 min read
Stop Reinventing the Wheel: Use Python’s Built‑In Queue for Fast, Thread‑Safe Tasks
Raymond Ops
Raymond Ops
Jul 9, 2025 · Big Data

Master Kafka: From Basics to Multi‑Broker Cluster Setup

This comprehensive guide introduces Apache Kafka's core concepts—topics, partitions, producers, consumers, and APIs—covers common use cases, walks through downloading, installing, and configuring a single‑node broker, demonstrates multi‑broker clustering, and explains how to use Kafka Connect for data import and export.

Distributed StreamingInstallationProducer Consumer
0 likes · 26 min read
Master Kafka: From Basics to Multi‑Broker Cluster Setup
Cognitive Technology Team
Cognitive Technology Team
Mar 9, 2025 · Backend Development

Understanding wait() and notify() in Java Multithreading

This article explains the concepts, usage conditions, execution flow, internal mechanisms, and best‑practice guidelines for Java's wait() and notify() methods, illustrated with a producer‑consumer example and code snippets for safe thread coordination.

JavaNotifyProducer Consumer
0 likes · 6 min read
Understanding wait() and notify() in Java Multithreading
Java Architecture Stack
Java Architecture Stack
Sep 30, 2024 · Backend Development

Mastering Unbounded and Bounded Queues in Java: When to Use Each

This article explains the concepts, characteristics, and ideal scenarios for unbounded and bounded queues in Java, provides step‑by‑step Maven setup and complete code examples for asynchronous task scheduling, event‑driven processing, and API rate‑limiting, and highlights practical considerations such as resource management and performance.

Bounded QueueJavaProducer Consumer
0 likes · 23 min read
Mastering Unbounded and Bounded Queues in Java: When to Use Each
vivo Internet Technology
vivo Internet Technology
Aug 14, 2024 · Backend Development

Understanding Disruptor: High‑Performance In‑Memory Queue, Core Concepts, Demo, and Source Code Analysis

The article explains the Disruptor—an intra‑process, lock‑free, array‑based queue that achieves millions of operations per second—by covering its core concepts, demo code, source‑code mechanics, performance optimizations such as pre‑allocation and false‑sharing avoidance, and real‑world Vivo iTheme applications with best‑practice tips.

DisruptorJavaProducer Consumer
0 likes · 29 min read
Understanding Disruptor: High‑Performance In‑Memory Queue, Core Concepts, Demo, and Source Code Analysis
Java Architect Essentials
Java Architect Essentials
Apr 1, 2024 · Backend Development

Introducing Disruptor: A High‑Performance In‑Memory Queue with a Complete Java Demo

This article introduces the open‑source Java library Disruptor, explains its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step demo with Maven dependency, event model, factory, handler, and a Spring‑Boot test illustrating high‑throughput producer‑consumer messaging.

Backend DevelopmentDisruptorJava
0 likes · 11 min read
Introducing Disruptor: A High‑Performance In‑Memory Queue with a Complete Java Demo
MaGe Linux Operations
MaGe Linux Operations
Dec 3, 2023 · Backend Development

Master RabbitMQ: Core Concepts, Programming Models, and Spring Boot Integration

This guide explains RabbitMQ fundamentals—including brokers, virtual hosts, connections, channels, exchanges, queues, producers, and consumers—covers common messaging patterns, provides step‑by‑step Java code for creating connections, declaring exchanges and queues, publishing and consuming messages, handling acknowledgments and confirmations, and shows how to integrate RabbitMQ with Spring Boot.

AMQPJavaMessage Queue
0 likes · 17 min read
Master RabbitMQ: Core Concepts, Programming Models, and Spring Boot Integration
Java High-Performance Architecture
Java High-Performance Architecture
Nov 19, 2023 · Backend Development

Boost Java Performance with Disruptor: A Hands‑On Guide to High‑Throughput Queues

This article introduces the high‑performance Java library Disruptor, explains its core concepts such as Ring Buffer, Sequence, and Wait Strategy, and provides a step‑by‑step demo with Maven configuration, code examples, and test results to help developers implement fast, lock‑free producer‑consumer queues.

DisruptorJavaMessage Queue
0 likes · 12 min read
Boost Java Performance with Disruptor: A Hands‑On Guide to High‑Throughput Queues
Java High-Performance Architecture
Java High-Performance Architecture
Nov 15, 2023 · Backend Development

Mastering Disruptor: High‑Performance Java Queue for Producer‑Consumer Systems

This article introduces the open‑source Disruptor framework, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategies, and provides a step‑by‑step Java demo—including Maven setup, event factory, handlers, and a test case—to illustrate building a high‑throughput, low‑latency in‑memory message queue.

DisruptorJavaMessage Queue
0 likes · 11 min read
Mastering Disruptor: High‑Performance Java Queue for Producer‑Consumer Systems
JD Retail Technology
JD Retail Technology
Nov 1, 2023 · Big Data

Kafka: Usage Scenarios, Core Concepts, Installation, Configuration, and Practical Operations

This article provides a comprehensive guide to Apache Kafka, covering its typical use cases, fundamental terminology, step‑by‑step installation and environment preparation, detailed configuration of brokers and topics, cluster deployment, producer‑consumer commands, and a Java client example for sending messages.

Distributed MessagingInstallationJava Client
0 likes · 21 min read
Kafka: Usage Scenarios, Core Concepts, Installation, Configuration, and Practical Operations
JD Cloud Developers
JD Cloud Developers
Oct 25, 2023 · Backend Development

Master Kafka: Core Concepts, Architecture, and Practical Tips

This article explains Kafka's fundamentals, including topics, partitions, brokers, replication, producer‑consumer workflow, consumer groups, offset management, and common exception handling, while providing code examples and diagrams to help developers understand and effectively use this distributed messaging system.

Distributed SystemsJavaKafka
0 likes · 21 min read
Master Kafka: Core Concepts, Architecture, and Practical Tips
Selected Java Interview Questions
Selected Java Interview Questions
Aug 8, 2023 · Big Data

Processing 10GB Age Data on a 4GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Solutions

This article demonstrates how to generate, read, and analyze a 10 GB file of age statistics on a 4 GB RAM, 2‑core machine using Java, comparing a single‑threaded counting method with a producer‑consumer multi‑threaded approach that dramatically improves CPU utilization and reduces processing time.

Big DataJavaMemory Management
0 likes · 11 min read
Processing 10GB Age Data on a 4GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Solutions
360 Quality & Efficiency
360 Quality & Efficiency
Apr 7, 2023 · Backend Development

RabbitMQ Introduction: Installation, Basic and Advanced Producer/Consumer Patterns, Exchanges, and Common Issues

This guide introduces RabbitMQ, explains how to install it with Docker, covers basic and advanced producer/consumer usage including acknowledgments, durability, QoS, bindings, and exchange types, and discusses a typical Python reconnection problem, providing a practical overview for backend developers.

DockerExchangeMessage Queue
0 likes · 5 min read
RabbitMQ Introduction: Installation, Basic and Advanced Producer/Consumer Patterns, Exchanges, and Common Issues
vivo Internet Technology
vivo Internet Technology
Mar 22, 2023 · Mobile Development

DropBoxManagerService Source Code Analysis and Client Log File Management Design

The article examines Android's DropBoxManagerService architecture, its configurable file retention policies, naming conventions, atomic operations, and broadcast mechanisms, then applies these patterns to propose a client‑side log management system using a producer‑consumer model with prioritized temporary storage, rename‑based reporting, and FileObserver‑driven collection respecting network, data, timing, priority, and battery constraints.

AndroidDropBoxManagerServiceLog Management
0 likes · 14 min read
DropBoxManagerService Source Code Analysis and Client Log File Management Design
Java Architect Essentials
Java Architect Essentials
Oct 31, 2022 · Big Data

How to Process 10 GB of Age Data on a 4 GB Machine Using Java

This article walks through generating a 10 GB file of age values, reading it line‑by‑line on a 4 GB RAM, 2‑core machine, measuring single‑thread performance, then redesigning the pipeline with a producer‑consumer model, blocking queues and multithreaded string splitting to dramatically boost CPU utilization and cut processing time while managing memory consumption.

Big DataFile ProcessingJava
0 likes · 12 min read
How to Process 10 GB of Age Data on a 4 GB Machine Using Java
Laravel Tech Community
Laravel Tech Community
Aug 22, 2022 · Backend Development

Implementing a Producer‑Consumer Model with RabbitMQ in PHP

This tutorial explains the producer‑consumer principle using RabbitMQ, provides a reusable PHP base class for queue connections, and demonstrates how to create service and client classes to send and receive messages, followed by step‑by‑step instructions to run the code and view the queue.

Backend DevelopmentMessage QueuePHP
0 likes · 3 min read
Implementing a Producer‑Consumer Model with RabbitMQ in PHP
Java Backend Technology
Java Backend Technology
Jul 1, 2022 · Big Data

How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading

This article explains how to generate a 10 GB file of age data, read it efficiently on a machine with limited memory, and use both single‑threaded and multithreaded Java techniques—including a producer‑consumer model and divide‑and‑conquer—to identify the age that appears most frequently, while analyzing performance, memory usage, and CPU utilization.

Big DataFile ProcessingJava
0 likes · 13 min read
How to Find the Most Frequent Age in a 10 GB File Using Java Multithreading
Architect
Architect
May 24, 2022 · Big Data

Processing 10 GB Age Data on a 4 GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Approaches

The article presents a complete Java solution for generating, reading, and analyzing a 10 GB file of age values (18‑70) on a 4 GB RAM, 2‑core PC, comparing single‑threaded counting with a producer‑consumer multithreaded design that dramatically improves CPU utilization and reduces total processing time.

JavaPerformance OptimizationProducer Consumer
0 likes · 20 min read
Processing 10 GB Age Data on a 4 GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Approaches
IT Architects Alliance
IT Architects Alliance
Apr 29, 2022 · Fundamentals

Why Your Java Producer‑Consumer Code Deadlocks and How to Fix It

This article explains the root causes of thread‑safety problems in Java producer‑consumer scenarios, demonstrates how race conditions and deadlocks arise, and provides step‑by‑step solutions using synchronized blocks, wait/notify, notifyAll, and explicit Lock with Condition objects.

JavaLockProducer Consumer
0 likes · 20 min read
Why Your Java Producer‑Consumer Code Deadlocks and How to Fix It
Sohu Tech Products
Sohu Tech Products
Apr 27, 2022 · Backend Development

Design Patterns Used in the Austin Project: Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy

This article explains how the Austin Java backend project applies several classic design patterns—including Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy—detailing their benefits, drawbacks, and specific code locations for each pattern.

BuilderChain of ResponsibilityDesign Patterns
0 likes · 6 min read
Design Patterns Used in the Austin Project: Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 1, 2020 · Fundamentals

Producer-Consumer Problem and wait()/notify() in Java

This article explains the classic producer‑consumer concurrency model, its advantages of decoupling, asynchrony and speed balancing, and demonstrates how Java’s wait(), notify() and notifyAll() mechanisms are used to coordinate producer and consumer threads with sample code implementations.

JavaProducer Consumerwait/notify
0 likes · 9 min read
Producer-Consumer Problem and wait()/notify() in Java
MaGe Linux Operations
MaGe Linux Operations
Aug 24, 2020 · Fundamentals

Why Coroutines Outperform Threads: A Deep Dive into Python’s Generator Magic

Coroutines, also known as micro‑threads, allow a single thread to pause and resume functions, offering higher efficiency than traditional multithreading by eliminating context‑switch overhead and lock contention, with Python’s generator‑based implementation enabling lock‑free producer‑consumer patterns and seamless multi‑core utilization via processes.

Producer ConsumerPythonconcurrency
0 likes · 7 min read
Why Coroutines Outperform Threads: A Deep Dive into Python’s Generator Magic
Xiao Lou's Tech Notes
Xiao Lou's Tech Notes
Jun 18, 2020 · Backend Development

How to Build an Ultra‑Fast Ring Buffer for Producer‑Consumer in Java

This article explains a high‑performance ring buffer implementation for a multi‑threaded producer‑consumer model in Java, covering design choices, atomic index handling, benchmark results, and further optimizations such as cache‑line padding and multi‑buffer sharding.

AtomicIntegerJava concurrencyProducer Consumer
0 likes · 10 min read
How to Build an Ultra‑Fast Ring Buffer for Producer‑Consumer in Java
Java Captain
Java Captain
Jun 16, 2019 · Fundamentals

Thread Coordination in Java: Analogies, Scenarios, and Classic Concurrency Patterns

This article uses everyday analogies to explain thread coordination, then demonstrates practical Java examples for stopping threads with flags, pausing/resuming, joining, barrier synchronization, exchanging tools, and phaser control, and finally ties them together with the classic producer‑consumer problem using locks and conditions.

JavaProducer ConsumerThread Coordination
0 likes · 21 min read
Thread Coordination in Java: Analogies, Scenarios, and Classic Concurrency Patterns
Tencent Music Tech Team
Tencent Music Tech Team
Apr 12, 2019 · Mobile Development

Understanding Android BufferQueue: Architecture and Internal Operations

Android’s BufferQueue, the core producer‑consumer mechanism behind the display pipeline, manages GraphicBuffer slots through explicit FREE‑DEQUEUED‑QUEUED‑ACQUIRED transitions, using shared memory and Binder to let producers (e.g., Views, MediaCodec) enqueue frames and consumers (e.g., SurfaceFlinger) acquire and release them efficiently.

AndroidBufferQueueGraphics
0 likes · 16 min read
Understanding Android BufferQueue: Architecture and Internal Operations
Programmer DD
Programmer DD
Nov 9, 2018 · Backend Development

How Java’s Producer‑Consumer Problem Evolved: From Classic Locks to BlockingQueue and Thread Pools

This article walks through the classic Java producer‑consumer synchronization challenge, shows its traditional lock‑based solution, then demonstrates modern approaches using BlockingQueue and ExecutorService thread pools to simplify code, improve reliability, and avoid common pitfalls like deadlocks and thread starvation.

BlockingQueueJavaProducer Consumer
0 likes · 15 min read
How Java’s Producer‑Consumer Problem Evolved: From Classic Locks to BlockingQueue and Thread Pools
MaGe Linux Operations
MaGe Linux Operations
Dec 11, 2017 · Big Data

Master Kafka Basics: Architecture, Core Concepts, and Hands‑On Python Experiments

This article explains Kafka’s core concepts—including producers, consumers, topics, partitions, brokers, and consumer groups—describes its distributed architecture with leader‑follower replication, and provides three hands‑on kafka‑python experiments that demonstrate basic messaging, fault‑tolerant consumer groups, and offset management for reliable consumption.

Distributed StreamingKafkaOffset Management
0 likes · 9 min read
Master Kafka Basics: Architecture, Core Concepts, and Hands‑On Python Experiments
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 21, 2017 · Backend Development

Mastering Producer‑Consumer and Pub/Sub with RabbitMQ: Real‑World Patterns Explained

This article explains the producer‑consumer and publish‑subscribe messaging patterns, introduces RabbitMQ’s core concepts such as exchanges, queues, routing keys, and reliability mechanisms, and demonstrates how to apply these patterns to data ingestion and event distribution scenarios with practical diagrams.

Backend ArchitectureMessage QueueMessaging Patterns
0 likes · 9 min read
Mastering Producer‑Consumer and Pub/Sub with RabbitMQ: Real‑World Patterns Explained
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 21, 2017 · Backend Development

Mastering Kafka: Producer‑Consumer vs Pub/Sub Patterns for Scalable Backend Design

This article explains Kafka's core concepts and compares producer‑consumer and publish‑subscribe models, illustrating how to apply each pattern for data ingestion and event distribution in distributed backend systems, and offers practical design alternatives when Kafka’s native capabilities fall short.

Backend ArchitectureKafkaMessage Queue
0 likes · 10 min read
Mastering Kafka: Producer‑Consumer vs Pub/Sub Patterns for Scalable Backend Design
Java Captain
Java Captain
Dec 7, 2016 · Fundamentals

Java Producer‑Consumer Example with Multiple Threads and Synchronization Improvements

This article explains the classic producer‑consumer problem in Java, demonstrates initial implementations using wait/notify with a single producer and consumer, analyzes issues that arise with multiple threads, and presents step‑by‑step code refinements—including while‑loops and notifyAll—to achieve correct multithreaded synchronization.

Producer ConsumernotifyAllthread synchronization
0 likes · 9 min read
Java Producer‑Consumer Example with Multiple Threads and Synchronization Improvements
Meituan Technology Team
Meituan Technology Team
Aug 5, 2016 · Backend Development

Distributed Queue Programming Models: Concepts, Architectures, and Practices

Distributed queue programming treats a queue as a fundamental, cross‑process abstraction, guiding developers to select synchronous or asynchronous, decoupled, persistent messaging solutions and offering four core models—point‑to‑point, producer‑consumer, publish‑subscribe, and MVC—while the article illustrates real‑world designs for billing, cache updates, and ticket processing.

Backend DevelopmentMessagingProducer Consumer
0 likes · 22 min read
Distributed Queue Programming Models: Concepts, Architectures, and Practices
Architect
Architect
Jun 14, 2016 · Backend Development

Custom Rejection Policies and Blocking Strategies for Java ThreadPoolExecutor

The article explains how to design a producer‑consumer model using Java's BlockingQueue, customize ThreadPoolExecutor's rejection policies—especially replacing the default AbortPolicy with a blocking strategy via a custom RejectedExecutionHandler—to safely handle full queues and improve concurrency control.

BlockingQueueJavaProducer Consumer
0 likes · 5 min read
Custom Rejection Policies and Blocking Strategies for Java ThreadPoolExecutor
21CTO
21CTO
Sep 14, 2015 · Backend Development

Why Apache Kafka Beats Traditional Message Queues: Architecture, Code, and Performance

This article explains Apache Kafka's distributed publish‑subscribe design, core components, storage model, ZooKeeper coordination, performance benchmarks against ActiveMQ and RabbitMQ, and provides Java producer and consumer code examples for building high‑throughput messaging applications.

Apache KafkaDistributed MessagingMessage Queue
0 likes · 16 min read
Why Apache Kafka Beats Traditional Message Queues: Architecture, Code, and Performance