This article explains what Java virtual threads are, compares them with ordinary platform threads, shows how to enable them in SpringBoot, and presents performance benchmarks that reveal virtual threads can be up to two hundred times faster for I/O‑bound workloads.
This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, analyzes the pool’s design, task submission methods, work‑stealing mechanism, common pool pitfalls, and presents performance evaluation results.
This article compares the effects of Concurrency (virtual user) mode and RPS (requests per second) mode in the Forcebot load‑testing platform on key service performance indicators such as TPS, TP99 and TP999, using a product‑query‑tag scenario to illustrate practical differences and recommendations.
The article explains how to use PHP’s curl_multi_select() function to wait for active cURL transfers in a multi‑handle scenario, detailing its definition, parameters, behavior, and providing a complete example that demonstrates efficient concurrent HTTP requests handling.
This article examines Go’s internal lock‑free single‑producer multi‑consumer queues—PoolDequeue and its dynamic extension PoolChain—detailing their design, atomic operations, and benchmark comparisons that show they can be up to ten times faster than standard channels in a producer‑consumer workload.
This article explains Java's AbstractQueuedSynchronizer (AQS) framework, detailing its FIFO queue, state handling, entry‑wait queue, exclusive and shared lock acquisition, condition‑variable queues, and how core concurrency utilities like ReentrantLock, ReadWriteLock, CountDownLatch, Semaphore, and ThreadPoolExecutor are built on it.
This article introduces Python's async and await keywords, explains how they enable coroutine programming, and provides multiple practical examples including simple coroutine definitions, awaiting tasks, concurrent execution with asyncio.gather, HTTP requests using aiohttp, and resource management with custom coroutine-based managers.
This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.
This article details the discovery, analysis, and fix of a severe thread‑leak issue in a Java Spring MVC service caused by unsafe use of a shared CloseableHttpAsyncClient, showing how multithreaded testing reproduced the problem and how refactoring the client to a local variable eliminated the runaway thread growth.
This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.
JEP 453 integrates StructuredTaskScope into Java 21, offering a preview API that replaces Future with Subtask, enabling lightweight virtual‑thread based concurrent tasks, such as fetching data from multiple servers and automatically cancelling slower calls, while simplifying error handling and improving observability.
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.
Operating systems are foundational software that manage hardware resources, provide core services like process and memory management, device and file handling, security, and user interfaces, while embodying key properties such as concurrency, sharing, asynchrony, and virtualization, and exist in various architectures from monolithic to microkernels.
This article demonstrates how PHP's Swow library executes tasks sequentially versus concurrently using coroutines, compares runtime differences, explains why the main coroutine exits early, and introduces synchronization utilities like waitAll, WaitGroup, and WaitReference with practical code examples.
This comprehensive guide explains the fundamentals of concurrent programming in Go, covering the differences between parallelism and concurrency, process and thread concepts, and detailed usage of goroutines, channels, select statements, timers, mutexes, read‑write locks, wait groups, once, sync.Map, and atomic operations with practical code examples and diagrams.
Bilibili tackled race‑condition vulnerabilities in its massive video content pipeline by replacing simple timestamp checks with optimistic locking (CAS) and rate‑limiting locks, adding version verification and observation tools that now eliminate missed reviews and improve security, scalability, and real‑time editing reliability.
This article breaks down the four Java ThreadPool rejection policies—AbortPolicy, CallerRunsPolicy, DiscardOldestPolicy, and DiscardPolicy—detailing their implementation, ideal use cases, advantages, and drawbacks to help developers choose the right strategy for handling overloaded executors.
This article explains the Redisson IllegalMonitorStateException caused by unlocking a lock held by another thread, analyzes the underlying node‑id and thread‑id concepts, and presents several practical solutions to correctly manage distributed locks in Java applications.
The article describes a Java‑based FIFO export queue that limits concurrent MySQL export operations, outlines the related classes (ExportQueue, AbstractExport, ExportImpl, and a test controller), provides full source code, and presents test results showing how the queue manages up to ten simultaneous export requests.
Modern databases have largely shifted from B‑tree based storage to LSM‑tree engines due to SSD hardware characteristics, high‑write workloads, concurrency advantages, simpler implementation, and evolving application demands, with additional insights into Paxos/Raft consensus, common database jargon, and performance optimizations.
This article explains what MySQL deadlocks are, outlines the four necessary conditions that cause them, provides a concrete example with SQL code, and offers practical strategies such as lock ordering, timeout settings, and MySQL’s built‑in detection to prevent and resolve deadlocks.
An in‑depth guide compares Go and Rust across memory management, learning curve, concurrency, ecosystem, performance, developer experience, and real‑world use cases, helping developers decide which language best fits cloud‑native services, system programming, web development, game development, or DevOps tools.
Fast‑Retry is a high‑performance, multi‑task asynchronous retry framework for Java that dramatically outperforms traditional synchronous retry libraries like Spring‑Retry and Guava‑Retry, especially when handling millions of tasks, by leveraging non‑blocking execution, customizable strategies, and seamless Spring integration.
This article explores Java virtual threads introduced in JDK 21, detailing their architecture, implementation, practical usage with Thread and Executors APIs, performance comparisons against platform threads, best‑practice guidelines, and benchmark results demonstrating superior throughput for high‑concurrency server applications.
The article analyses the design of Rust’s Mutex API, compares it with the classic C/POSIX mutex API, explores alternative Rust designs that mimic C, and demonstrates through concrete code examples why Rust’s guard‑based approach preserves safety while a C‑style API would re‑introduce data‑race hazards.
This article provides a comprehensive analysis of Java's ConcurrentHashMap, covering its underlying data structures, key attributes, core components such as Node, ForwardingNode, TreeBin, and TreeNode, and detailed explanations of the put, get, hash, and resizing algorithms with annotated source code examples.
This article introduces the Fork/Join model and ForkJoinPool in Java, explains divide‑and‑conquer principles, provides sample RecursiveTask code for summing ranges, analyzes pool construction, task submission, work‑stealing, monitoring methods, and presents performance experiments highlighting task granularity impact.
This article provides a comprehensive guide to Go's concurrency model, covering goroutine creation, the scheduler, communication via channels, handling race conditions, and synchronization techniques using atomic operations and mutexes, complete with practical code examples and visual diagrams.
This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.
This article introduces experienced Python developers to advanced techniques and best practices, covering high‑level data structures from the collections module, custom data structures, decorators and context managers, metaclasses, dynamic class creation, concurrent and asynchronous programming, performance tuning, memory management, coding standards, and testing strategies.
The article examines Go's coroutine architecture and its GMP (Goroutine-Machine-Processor) model, tracing coroutine history, comparing kernel, user, and hybrid thread models, and detailing G, M, and P components, scheduling principles, work-stealing, preemption, and runtime implementation that give Go high concurrency and low latency.
This article explains five common ways to ensure thread safety in Java, covering synchronized blocks, the Lock interface, atomic variables, concurrent collections, and ThreadLocal usage, each with clear code examples and practical advice.
To import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, the article examines data partitioning, B‑tree index limits, batch insertion, storage engine choices, concurrency control, file‑reading methods, task scheduling with Redis, Redisson, and Zookeeper for reliable, ordered, high‑throughput loading.
The article explains OpenAI's 2020 Scaling Laws that show larger transformer models, more data, and greater compute consistently improve performance, introduces the concept of emergent abilities at critical size thresholds, and outlines the core principles of parallel computing such as multi‑processor usage, task decomposition, concurrent execution, and inter‑processor communication.
This article explains what a dynamic thread pool is, why it is needed, how to modify its core parameters at runtime, how to monitor and expose its metrics, and lists open‑source implementations and visualization/alerting options such as Prometheus, Grafana, Hippo4j and Dynamic TP.
This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.
This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.
This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.
This article explains Java thread pools, their advantages, internal mechanics, common pitfalls such as oversized queues, excessive threads, and data loss on crashes, and presents a persistence‑based solution using database‑stored tasks and scheduled retries to ensure no data is lost when services go down.
This guide explains how SpringBoot's @Async annotation works, why to use it, how to configure default and custom thread pools, handle exceptions and return values, and leverage virtual threads for higher throughput in Java backend applications.
A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.
The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.
This article explains why exceptions thrown by tasks submitted to a Java thread pool behave differently with submit and execute, demonstrates how to capture those exceptions using Future.get, try‑catch, Thread.setDefaultUncaughtExceptionHandler, and by overriding afterExecute, and provides complete code examples for each approach.
PayPal’s rapid growth forced it to process millions of transactions daily, leading the engineering team to expand beyond a thousand virtual machines and confront escalating network, maintenance, and resource challenges, which they solved by adopting the Akka‑based Actor model and implementing a Go‑based actor system for efficient, fault‑tolerant concurrency.
This article explains how Java's ConcurrentHashMap provides thread‑safe, high‑performance map operations by comparing the segmented‑lock design of JDK 7 with the fine‑grained locking and CAS approach of JDK 8, and includes a practical multithreaded code example.
Using JDK 21’s standardized Virtual Threads, this guide explains how to design and implement robust asynchronous batch processing, covering common pitfalls like CPU spikes and OOM, best‑practice concurrency controls, task queue architecture, and practical code illustrations.
This article traces Rust’s origin from Graydon Hoare’s personal frustration with buggy elevators to its rise as a memory‑safe, high‑performance language adopted by major tech companies, highlighting its design principles, community culture, and impact on modern software development.
This article explains PHP 8.1's Fibers feature, describing how they enable lightweight cooperative multitasking, showing basic and advanced code examples for non‑blocking I/O, parallel API/database calls, and large‑file processing, and discusses benefits, use‑cases, and important limitations.
PayPal’s rapid growth forced a shift from simple hardware upgrades to a sophisticated, actor‑based architecture built on Akka, enabling efficient resource utilization, fault tolerance, and high‑throughput processing, ultimately allowing the company to handle billions of daily transactions using only eight virtual machines.
This article explores Rust's concurrent programming techniques, comparing traditional multithreading with Futures combinators, detailing thread creation, joining, returning values, the move keyword, and async execution using Tokio, and provides guidance on selecting the appropriate strategy based on task characteristics.
This article examines Netty 4.1.x’s ByteBuf reference‑counting mechanism, explains why reference counting was introduced, traces its original design, shows instruction‑level optimizations, reveals concurrency bugs in version 4.1.17, and details the clever even‑odd redesign that guarantees thread‑safe memory release while preserving high performance.
This article explains Java's HashMap implementation, covering its bucket array, linked‑list and red‑black tree handling, hash function perturbation, dynamic resizing, and thread‑safety considerations, providing code examples and diagrams for clear understanding.
This article explains the thundering herd phenomenon in multi‑process/thread servers, details its performance costs, demonstrates the issue with accept() and epoll_wait() through C examples, explores thread‑level herd, and presents mitigation techniques such as accept mutexes, SO_REUSEPORT, and Nginx's handling.
This article presents ten practical Python decorator patterns—such as logging, performance measurement, exception handling, retry, status‑code validation, parameter checking, rate limiting, data‑driven testing, environment configuration, and concurrent execution—each illustrated with clear use‑case descriptions and complete code snippets for API testing.
This article explains the limitations of Java's ThreadLocal and InheritableThreadLocal in thread‑pool scenarios, introduces Alibaba's open‑source TransmittableThreadLocal (TTL) library, and provides detailed code examples for safely transmitting thread‑local data across threads, thread pools, and even via Java agents.
This article provides a comprehensive guide to Java atomic variables, explaining their core concepts, underlying CAS mechanism, key classes such as AtomicInteger, AtomicLong, AtomicReference, and AtomicBoolean, and demonstrating practical code examples, use‑cases, performance benefits, limitations, and comparisons with traditional lock‑based synchronization.
This article explains the importance of caching, compares common replacement policies, and walks through a complete Go implementation of a thread‑safe local LRU cache, including interface design, data structures, linked‑list management, and concurrency handling.
This article explains how using Spring's @Transactional annotation together with explicit locks can cause unexpected concurrency issues, demonstrates the problem with sample code, analyzes why the lock becomes ineffective, and presents solutions such as separating transactional methods, using programmatic transactions, or locking the entire transaction.
The article outlines nine broadly applicable techniques—caching, parallel and batch processing, data compression, lock‑free design, sharding, eliminating unnecessary requests, and resource pooling—that together can dramatically cut service latency and improve throughput, as demonstrated by an 80% latency reduction in a real‑world project.
This article explains how to use Redis for distributed locking, discusses the shortcomings of naive implementations, and presents robust solutions including identifier verification, Lua scripting for atomicity, the RedLock algorithm, and Redisson's advanced features such as re‑entrancy and watchdog mechanisms.
This article introduces Lock4j, a Java distributed lock library supporting RedisTemplate, Redisson, and Zookeeper, walks through its key features, dependency setup, configuration, annotation attributes, simple and advanced usage examples, and demonstrates custom executors, key builders, and failure strategies for robust concurrency control.
This article explores the subtle timing of Spring transaction start and commit relative to lock/unlock, demonstrates how improper ordering can cause over‑selling in high‑concurrency scenarios, and provides debugging techniques and practical solutions to ensure atomicity and correct rollback behavior.
This article explains Python multithreading fundamentals, covering thread basics, the _thread and threading modules, creating and managing threads, synchronization with locks, ThreadLocal usage, thread pools, and compares multithreading with multiprocessing for CPU‑bound and I/O‑bound tasks.
This article explains how to prevent multiple simultaneous token requests in a web application by using a custom repeatOnce function that caches the token in localStorage and coordinates pending calls through an event emitter, ensuring only the first request fetches the token while others wait for its result.
Rust 1.80 introduces LazyCell and LazyLock, synchronized lazy-initialization primitives that differ from OnceCell and OnceLock in thread safety and built‑in initialization, and this article explains their characteristics, trade‑offs, and provides concrete code examples to help developers select the appropriate type for their use case.
This article explains how TCP connections are identified, the theoretical maximum numbers for client and server sides, and why real‑world limits are governed by system resources, port reuse, and server architecture rather than the 65,535 port ceiling.
This article provides a comprehensive overview of Python multithreading, covering basic concepts, the _thread and threading modules, thread creation methods, synchronization primitives like Lock and RLock, thread-local storage, thread pools, and the differences between multithreading and multiprocessing for both CPU‑bound and I/O‑bound workloads.
The article explains why a backend team moved from PHP to Go for high‑concurrency live‑streaming services and demonstrates two Go concurrency patterns—sync.WaitGroup and errgroup—with code examples and common pitfalls.
This article explains how to use Go's context package for managing request-scoped data, cancellation, deadlines, and timeouts, compares it with Java's ThreadLocal approach, and provides practical code examples for creating contexts, handling goroutine lifecycles, and applying context in network programming.
This article examines why Kotlin coroutine concepts are hard to explain, identifies common shortcomings in existing tutorials, and proposes a step‑by‑step approach that starts from basic thread concepts, uses incremental examples, and introduces task‑flow techniques to clarify coroutine behavior.
This article presents eight practical retry mechanisms for Java applications—including loop, recursion, HttpClient configuration, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries—along with code examples, configuration snippets, and best‑practice guidelines to help developers handle transient network failures reliably.
This article explores Go's built‑in concurrency primitives—including Mutex, RWMutex, Condition variables, atomic operations, sync.Once, and WaitGroup—detailing their purposes, usage patterns, and best‑practice guidelines to write correct and efficient concurrent programs.
This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool in Java, demonstrates how to implement custom RecursiveTask and RecursiveAction classes with code examples, discusses pool construction, task submission, work‑stealing, monitoring methods, performance testing, and cautions about using the common pool.
The article explains that Spring MVC controllers are singleton by default, which makes mutable instance fields unsafe for concurrent requests, demonstrates the issue with sample code, and shows how applying @Scope("prototype") or using ThreadLocal resolves the thread‑safety problem.
This article summarizes the common pitfalls, monitoring techniques, configuration guidelines, naming conventions, and practical code examples for safely using Java ThreadPoolExecutor, helping developers avoid OOM, deadlocks, and performance issues while optimizing thread‑pool usage.
This article explains Go's memory management by detailing stack and heap differences, describing classic and modern garbage‑collection algorithms, tracing the evolution of Go's GC from version 1.3 to 1.8, and outlining a complete GC cycle with practical code examples.
The article examines why internet architectures have become increasingly complex, explains the unique challenges of flash‑sale (秒杀) business scenarios, and presents practical backend optimization techniques such as request filtering, Redis caching with atomic operations, ordered queues, data‑layer safeguards, and unit‑based isolation for global deployments.
This article explains Java's lock escalation process—covering biased, lightweight, and heavyweight locks—their underlying mechanisms, performance benefits, and the conditions under which each lock type is applied in multithreaded applications.
Java thread pools efficiently manage and reuse threads by applying a producer‑consumer model, transitioning through RUNNING, SHUTDOWN, STOP, and TERMINATED states, handling task queues, and employing configurable rejection policies such as Abort, CallerRuns, Discard, and DiscardOldest, while improving performance, resource utilization, and stability across web servers, asynchronous processing, and other concurrent workloads, distinct from connection pools which manage database connections.
This article explains how to handle massive MySQL export operations by introducing a fixed‑size FIFO queue, detailing the Java classes ExportQueue, AbstractExport, and ExportImpl, and showing a test controller that demonstrates queue limits, concurrency handling, and future considerations.
This article analyzes why two identical DELETE statements on a MySQL table with a unique index can deadlock, explains InnoDB lock types, walks through the execution flow, reproduces the issue with SQL and Java code, and discusses mitigation strategies.
This article explains how to implement distributed locks using Redis, starting with a basic SETNX approach, identifying its shortcomings, and then presenting robust solutions such as identifier‑based unlocking, Lua scripts for atomicity, the RedLock algorithm, and Redisson’s advanced features including a watchdog mechanism.
This article presents a comprehensive guide to improving Java backend performance by using parallel processing with CompletableFuture, minimizing transaction scope, applying effective caching strategies, configuring thread pools, reducing object creation, and employing various concurrency controls such as volatile, CAS, and read‑write locks.
This article explains why browsers limit concurrent HTTP requests, demonstrates the limitation with a test example, and provides a reusable PromiseLimiter class that queues and throttles asynchronous calls to keep the number of simultaneous requests under a defined threshold.
This article details a step‑by‑step investigation of a JSF thread‑pool exhaustion error that occurred when upgrading the Redis version of JD's internal R2M distributed cache, analyzing stack traces, lock contention, ForkJoinPool behavior, and the eventual remediation steps.
This article explains the concept of false sharing caused by CPU cache line interactions, demonstrates how cache padding can mitigate the performance penalty, and provides Go benchmark code and results to illustrate the impact on multi‑core concurrency.
This article walks through practical Java backend performance techniques—including parallel processing with CompletableFuture, fine‑tuned thread‑pool configuration, transaction scope minimization, cache‑line awareness, object‑pool usage, lock granularity, copy‑on‑write collections, and network payload reduction—backed by concrete code samples, benchmark results, and step‑by‑step analysis of trade‑offs and best practices.
This article explores eleven practical approaches for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, thread‑pool executors, popular message‑queue solutions such as RocketMQ and RabbitMQ, as well as Redis‑based techniques, Redisson, Netty, Hutool, Quartz, and simple polling implementations.
This article explores eleven practical methods for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, advanced executors such as ScheduledThreadPoolExecutor, and popular messaging solutions including RocketMQ, RabbitMQ, Redis, Redisson, Netty, Hutool, and Quartz, with code demos and implementation details.
This article explains the Fork/Join model and Java's ForkJoinPool, covering the divide‑and‑conquer algorithm, custom RecursiveTask examples, core source‑code analysis, common pool pitfalls, and performance testing to help developers decide when and how to use ForkJoinPool effectively.
This article introduces Gleam, a type‑safe functional language that compiles to Erlang and JavaScript, walks through installation, a hello‑world program, package management, pattern matching with algebraic data types, and demonstrates its concurrency‑friendly, null‑free design.
This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, provides performance benchmarks, and discusses design details, task submission methods, work‑stealing, and cautions about using the common pool.
This article explains Java virtual threads introduced in Java 19, compares them with traditional OS threads, shows how to enable them in Spring Boot, and presents performance benchmarks that demonstrate dramatic latency reductions for I/O‑bound workloads.
This article explores various MySQL write performance tests using different concurrency levels—Statement, Connection, and database-level parallelism—provides benchmark results, sample Java/Groovy code, and discusses key configuration and architectural factors that influence write throughput.
The article explains why fail‑fast iterators throw ConcurrentModificationException when a collection is modified during iteration, outlines two common scenarios that trigger the exception, and presents both incorrect and correct Java code examples along with strategies such as avoiding modifications, using synchronization, iterator.remove(), or switching to fail‑safe concurrent collections.
This article explains how Java's parallelStream uses the shared ForkJoinPool, why developers may need to customize the thread pool for better performance and isolation, and provides two approaches—setting the system property and creating a dedicated ForkJoinPool—along with complete code examples and execution results.
Huawei unveiled the fully self‑developed Cangjie programming language at the 2024 Developer Conference, detailing its native intelligence, full‑scene support, high performance, strong security, multi‑paradigm features, and simple syntax designed specifically for HarmonyOS applications.
This article explains what Java virtual threads are, compares them with traditional threads, shows how to enable them in SpringBoot with configuration and code examples, and presents performance tests that demonstrate dramatic speed improvements for IO‑bound workloads.
This article describes a real‑world incident where rapid pod scaling caused order‑submission failures in a serverless e‑commerce platform, analyzes the root causes, and presents a Go‑based graceful‑shutdown solution—including ASyncClose, SyncClose, and ForceSyncClose modes—implemented in the open‑source GS library to help developers reliably terminate services.
This article explains how Java's CompletableFuture extends traditional concurrency tools with rich APIs for parallel execution, chaining, error handling, and timeout management, providing clear code examples that demonstrate building maintainable asynchronous applications.
