Through a multithreaded test program, this article explores whether Java’s 64‑bit long and double types are accessed atomically on 32‑bit and 64‑bit JVMs, explains the JVM memory model rules, and shows how volatility and hardware affect atomicity.
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.
This article explains the concept, purpose, and internal workings of Java's ThreadPoolExecutor, covering thread lifecycle, pool creation parameters, common blocking queues, thread factories, rejection policies, and the execute() method with code examples to help developers efficiently manage concurrent tasks.
This article explains why the Thread.stop and Thread.suspend methods were deprecated in modern Java, demonstrates the problems they cause with concrete code examples, and presents two safe alternatives—using a shared flag and the interrupt mechanism—to gracefully terminate threads without risking deadlocks or resource leaks.
This article explains four Java concurrency utilities—CountDownLatch, CyclicBarrier, Semaphore, and Exchanger—detailing their concepts, typical use cases, and providing complete code examples that demonstrate synchronization patterns such as thread coordination, resource limiting, and data exchange.
This guide explains how Spring's @Async annotation works, compares built-in executors, shows how to configure custom thread pools via AsyncConfigurer or AsyncConfigurerSupport, and demonstrates various async method signatures including void, Future and CompletableFuture with practical code examples.
The article explains why multithreading is essential for modern CPUs, introduces thread pools to reduce overhead, and details Java's ThreadPoolExecutor creation parameters, execution process, and core methods such as addWorker, runWorker, and getTask, using JDK 1.8 source code examples.
Java's ThreadPoolExecutor offers four rejection policies—AbortPolicy, DiscardPolicy, DiscardOldestPolicy, and CallerRunsPolicy—each handling task overflow differently; this article explains their behavior, default setting, code examples, and how to configure them via Spring's ThreadPoolTaskExecutor for various business scenarios.
The article presents a detailed interview‑style walkthrough of MySQL InnoDB locking mechanisms, covering table‑ versus row‑level locks, shared and exclusive locks, intention locks, gap and next‑key locks, auto‑increment locks, predicate locks, and related SQL statements, illustrated with tables and code examples.
This article examines several subtle Go programming issues—including unexpected loop variable addresses, the scope nuances of the := operator, proper handling of goroutine concurrency with worker pools, and how struct field ordering affects memory alignment—providing code examples and practical solutions to avoid these pitfalls.
The article provides a comprehensive overview of Java garbage‑collection algorithms, JVM memory regions, object reachability analysis, the semantics of volatile, synchronized and ReentrantLock, thread‑pool creation and operation, deadlock examples, distributed‑lock strategies, and related tooling such as JUC utilities and Git conflict handling.
This article explains the different blocking queue implementations—ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, and PriorityBlockingQueue—used by Java thread pools, describing their structures, behavior, fairness settings, and performance characteristics for concurrent task execution.
This article explains the two core properties of Java's volatile keyword—visibility and ordering—how they are implemented via lock prefixes and memory barriers, compares volatile with synchronized and CAS, and details the underlying CPU cache‑coherency mechanisms such as MESI, store buffers, and invalidate queues.
This article explains why thread start order differs from execution order in Java and demonstrates four techniques—Thread.join, a single‑thread executor, a volatile flag, and ReentrantLock with conditions—to guarantee that multiple threads run and print their results in a deterministic sequence.
This article explains the various Java lock mechanisms—including optimistic and pessimistic locks, exclusive and shared locks, reentrant, read‑write, fair/unfair, spin, segment locks, and lock‑escalation techniques—detailing their principles, Java implementations, usage scenarios, and optimization strategies.
A Java multithreading example shows that synchronizing on a mutable Integer field does not guarantee exclusive access, and the article explains the root cause, demonstrates correct locking techniques, and offers best‑practice tips for safe concurrent programming.
This article explains the concepts of processes and threads, compares their characteristics, outlines their respective advantages and disadvantages, and provides practical guidelines for choosing between multithreading and multiprocessing in software design.
This article explores the performance drawbacks of java.util.Random in high‑concurrency scenarios, explains how ThreadLocalRandom leverages Unsafe for per‑thread seeds, examines native getLong/putLong operations, and discusses memory layout nuances such as compressed oops and potential pitfalls.
This article presents a comprehensive collection of Baidu C++ engineers' performance‑optimization practices, covering memory‑access patterns, string handling, protobuf manipulation, allocator choices, job‑level memory arenas, cache‑line considerations, and memory‑order semantics to achieve substantial latency and cost reductions in large‑scale backend services.
This article provides a comprehensive beginner‑friendly walkthrough of Go, covering its origins, installation, environment variables, IDE setup, project structure, core syntax, data types, functions, object‑oriented concepts, and a practical concurrency example using goroutines and channels.
This article explains the fundamental concepts of processes and threads in operating systems, compares their characteristics, outlines their respective advantages and disadvantages, and provides practical guidelines for choosing between multi‑process and multi‑thread designs in real‑world applications.
This article investigates whether long and double variables are atomic in the JVM, demonstrates non‑atomic behavior on 32‑bit HotSpot with a multithreaded test, explains the Java Memory Model rules, and shows that atomicity is guaranteed on 64‑bit JVMs or when using volatile.
The article explains why Java's synchronized lock cannot be used for distributed scenarios, demonstrates how to build a Redis‑based distributed lock with setIfAbsent, discusses pitfalls such as server crashes and lock expiration, and presents robust solutions including atomic expiration, thread‑ID verification, lock renewal, and Redisson usage.
This article compares Java's Timer and ScheduledExecutorService for scheduling tasks, explains their internal workings, demonstrates common pitfalls, and provides multiple code examples showing how to schedule one‑off, fixed‑rate, and fixed‑delay tasks using both Runnable and Callable.
This article walks through a rapid three‑day Go onboarding, covering installation, environment setup, core syntax, package management with Go modules, common development tools, and a simple producer‑consumer concurrency example, while comparing Go concepts to Java and JavaScript.
This article explains how to design and implement a task‑orchestration workflow using a directed acyclic graph (DAG) in Java, covering graph representation, core data structures, concurrency handling with executors, persistence to a database, and platform‑level visualisation.
This guide shows how to use Zookeeper 3.6.2 with Spring Boot 2.2.10 to create sequential nodes, implement a distributed ID service in Java, and test concurrent ID generation across 100 threads.
This article explains how to write a concurrent unit test for the AssetService.update method using thread pools, CountDownLatch, AtomicInteger, and then suggests optimizations such as replacing AtomicInteger with LongAdder and employing CyclicBarrier to increase contention, providing full code examples and detailed explanations.
This article explains the internal workings of Java's ReentrantLock, comparing fair and non‑fair lock acquisition, detailing the role of AQS, CLH queues, CAS operations, thread parking, and unlock procedures with full source‑code excerpts.
The article investigates the misconception that ThreadLocal can isolate database connections in a pool, demonstrates through a single‑connection Druid test that connections are effectively exclusive to a thread, and explains the underlying pool mechanics and proper use of ThreadLocal for routing data.
This article explains the concept, characteristics, and multiple implementation approaches of distributed locks, focusing on Redis‑based locks and the Redlock algorithm, and provides complete Java code examples using Spring Boot and Redisson for acquiring and releasing locks safely.
This article explains Go's MPG scheduling model, detailing how Goroutine, M, and P interact during blocking, asynchronous and synchronous system calls, the role of the netpoller, and the sysmon coroutine that enables preemptive scheduling and runtime monitoring.
This article explains how Kotlin coroutines simplify asynchronous programming on Android by using suspension, detailing core concepts, APIs, dispatchers, suspend functions, and the underlying implementation through decompiled bytecode and continuation‑passing style, complemented by practical code examples and execution logs.
This tutorial explains how to extract logs from a 16 GB file in about 25 seconds by reading the file in chunks, reusing buffers with sync.Pool, and processing those chunks concurrently with Go goroutines, avoiding full‑memory loads or slow line‑by‑line scans.
This article explains Java thread lifecycle states, detailing the six JVM-defined states (NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED), their transitions, and the finer distinction between READY and RUNNING within the RUNNABLE state, while clarifying why Java does not define a separate RUNNING state.
This article explains how Java thread pools work, clarifies common misconceptions about core thread creation, details the role of BlockingQueue, and provides practical guidelines for sizing core, max threads, and queue capacity based on concurrency and GC considerations.
This article reviews four Java random number generation techniques—Random, ThreadLocalRandom, SecureRandom, and Math.random()—detailing their usage, underlying algorithms, thread‑safety, performance trade‑offs, and appropriate scenarios, helping developers choose the right tool for their applications.
This article explains the concept of thread pools, their performance benefits, the three native Java pool implementations, detailed internal mechanisms of ThreadPoolExecutor, task queue choices, rejection policies, and practical tuning advice for real‑world applications such as Tomcat and custom frameworks.
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.
This article explains why StringBuilder is not thread‑safe, demonstrates the problem with a multithreaded example that produces a wrong length and occasional ArrayIndexOutOfBoundsException, and shows how StringBuffer’s synchronized implementation avoids these issues.
This article explains how to efficiently extract time‑range logs from a massive 16 GB .txt/.log file using Go's bufio.NewReader, sync.Pool for buffer reuse, and concurrent goroutines, achieving processing times of around 25 seconds.
The article reviews Baidu C++ engineers' concurrency optimizations, explaining why modern software must exploit parallelism and detailing SIMD vectorization, out‑of‑order execution, and micro‑architectural analysis, then compares mutex, lock‑free, and wait‑free synchronization, showcasing case studies where atomic and wait‑free designs dramatically improve multithreaded performance.
This article explains how to assess and design system capacity by analyzing real‑world scenarios—such as a company sports event—calculating required concurrency, average and peak QPS using the 80/20 rule, performing load tests, and determining instance counts to ensure reliable performance under varying traffic spikes.
This tutorial explains what Redisson is, how it extends Redis with powerful distributed data structures and lock mechanisms, and provides step‑by‑step Spring Boot integration, code examples, and detailed testing of re‑entrant, read‑write, and semaphore locks.
Learn how to efficiently extract timestamped logs from a massive 16 GB file in seconds using Go's buffered I/O, sync.Pool, and goroutine concurrency, with step‑by‑step code examples, performance tips, and a complete runnable program.
This article provides a comprehensive guide to Java multithreading, covering thread concepts, lifecycle states, synchronization methods, thread creation techniques, ThreadPoolExecutor parameters, blocking queues, rejection policies, and inter‑thread communication mechanisms, including examples and best practices for efficient concurrent programming.
This article explains the structural changes of ConcurrentHashMap in JDK 8, covering the new table layout, node types, hash spreading, initialization, resizing mechanics, treeification, and the lock‑free algorithms that enable concurrent expansion and high‑performance operations.
This article explains the origin of the "gopher" nickname for Go developers and provides a comprehensive guide on migrating legacy PHP services to Go, covering architectural decisions, project layout, concurrency control, error handling, and asynchronous task execution.
This article explains how to estimate and design system capacity—including traffic, concurrency, QPS, and resource requirements—by illustrating concepts, analytical formulas, peak‑load assessment techniques, performance testing, and a practical case study of a book‑reservation system.
This article explains the limitations of local locks in distributed systems and provides detailed implementations of distributed locks using Redis (SETNX, Lua scripts, Redisson) and ZooKeeper (ephemeral sequential nodes), complete with code examples and best‑practice recommendations.
This article reviews the evolution and improvements of PHP, outlines its modern features and limitations, then contrasts them with Go's static typing, concurrency, and performance advantages, ultimately arguing that using PHP together with Go can address many backend development challenges.
This article explains why multithreading and thread pools are essential for modern server-side Java development, details the full set of ThreadPoolExecutor constructor parameters, and walks through the executor, addWorker, Worker, runWorker, and getTask implementations using JDK 1.8 source code examples.
This article presents a comprehensive translation of the Swift Evolution proposal SE‑0282, detailing the design and implementation of low‑level atomic operations, memory orderings, and related types such as UnsafeAtomic and UnsafeAtomicLazyReference, providing examples and discussing integration with Swift’s concurrency model.
This article explains how to design and implement a user‑customizable scheduled‑task component in Java, addressing the limitations of open‑source frameworks by separating task creation, loading, scheduling, and execution, and provides practical code examples for robust backend task management.
This article explores the intricacies of Java's ThreadPoolExecutor, explaining how corePoolSize=0, thread creation, core thread timeout, keepAliveTime settings, exception handling, shutdown strategies, Spring equivalents, and provides practical best‑practice recommendations with code examples.
This article explains three common ThreadLocal misuse traps—memory leaks caused by weak‑referenced keys, loss of thread‑local context in thread‑pool workers, and context disappearance in parallel streams—provides detailed code examples, and offers practical guidelines to prevent them in Java backend applications.
This article explains Go’s context package, covering its purpose for managing goroutine lifecycles, the key interfaces and implementations such as emptyCtx, cancelCtx, timerCtx, and valueCtx, and demonstrates how to use WithCancel, WithDeadline, WithTimeout, and WithValue to control execution, propagate cancellations, and pass values across call chains.
This article provides a comprehensive explanation of Java's JUC origins, the design and implementation of AbstractQueuedSynchronizer (AQS), its template methods for exclusive and shared locks, the CLH queue mechanism, lock implementations, condition queues, and related code examples, illustrating how high‑performance concurrency primitives such as ReentrantLock, CountDownLatch, Semaphore, and ReentrantReadWriteLock work under the hood.
This article explains why Go's lightweight goroutines enable high concurrency, describes the need for a goroutine pool to control resource usage, outlines the pool's architecture with entry and job channels, and provides a complete Go implementation with example usage.
This article explains the concept of object pools, introduces Apache Commons Pool2 core interfaces and object states, details configuration parameters, describes the borrowing and returning workflow, and provides a complete Java example of a simple string pool implementation.
This article explains how ThreadLocal works in Java, demonstrates how improper use can cause Out‑Of‑Memory errors, analyzes the underlying cause in ThreadLocalMap, and provides a simple fix by invoking remove() after use to avoid memory leaks.
This article explains Java’s concurrency utilities CountDownLatch, CyclicBarrier, Semaphore, and Exchanger, illustrating their concepts with race‑style analogies, providing complete code examples, and showing execution results to demonstrate how threads can synchronize, wait, limit, and exchange data.
This article explains how to integrate Redisson into a Spring Boot application to implement various Redis‑based distributed synchronization primitives—including re‑entrant locks, read‑write locks, and semaphores—while covering configuration, code examples, the watchdog mechanism, and practical testing procedures.
This article explains the hardware memory hierarchy, cache‑coherency issues, processor optimizations and instruction reordering, and shows how the Java Memory Model (JMM) defines eight operations to guarantee visibility, atomicity and ordering for multithreaded Java programs.
This article reviews why asynchronous programming is needed, explains continuations, compares callbacks, promises, reactive streams, async/await, and user‑level threads, and shows how each technique reduces I/O blocking and improves concurrency in Java applications.
This article explains what ThreadLocal is, demonstrates how it works with and without it, analyses its source code, discusses potential memory‑leak issues, and provides best‑practice guidelines and a Spring‑Boot example for safe usage in multithreaded Java applications.
This article explores how a Java ThreadPoolExecutor behaves when a task triggers an OutOfMemoryError, demonstrates custom exception handling, compares the four built‑in rejection policies, and shows how to create a custom thread pool that records task execution time.
This article explains how to optimize Java scheduled tasks for large‑scale data synchronization by introducing phased improvements such as blacklist mechanisms, multithreaded execution with CountDownLatch, and server‑level sharding, providing practical guidelines for performance and reliability.
This article explains why SimpleDateFormat is not thread‑safe in Java, demonstrates the problem with multithreaded examples, and presents five practical solutions—including local variables, synchronized blocks, explicit locks, ThreadLocal, and the modern DateTimeFormatter—along with their advantages and drawbacks.
This article demonstrates how to configure and use Spring Boot's ThreadPoolTaskExecutor for asynchronous processing, shows custom thread‑pool monitoring, and provides complete code snippets and log examples to help improve batch‑insert performance in Java backend applications.
This article explains why ThreadLocal is both simple and tricky to use, demonstrates common pitfalls when formatting dates with SimpleDateFormat in multithreaded environments, analyzes thread‑safety issues, and provides practical solutions using synchronized blocks, ThreadLocal, and its advanced initialization methods for clean and efficient concurrent code.
This article explains Python's multiprocessing module, covering process concepts, creation of single and multiple processes, process pools, locks, inter‑process communication methods such as Event, Pipe, Queue, semaphores, and data sharing techniques, with code examples and visual illustrations.
This article explains the concepts of synchronous and asynchronous programming in Python, compares their architectures, discusses how async frameworks and greenlet‑based libraries work, and clarifies when asynchronous code can outperform synchronous code, especially under high I/O‑bound load.
This article analyzes the causes of data backlog in an ActiveMQ message queue, demonstrates how synchronized locks and default prefetch settings limit throughput, and presents three optimization phases—including removing the lock, adjusting queuePrefetch, and redesigning queue handling—to achieve over 30‑fold performance improvement.
This article provides a comprehensive tutorial on Java concurrency, covering the usage and implementation principles of the volatile and synchronized keywords, the Java Memory Model, the MESI cache protocol, common visibility and reordering issues, and practical code examples for designing efficient multithreaded solutions.
The article outlines why high‑load Go services need performance tuning and presents a systematic workflow—preparation, analysis with Linux tools and Go’s pprof/trace, targeted optimizations such as goroutine pooling, Redis MSET, efficient JSON handling and slice resizing—demonstrating how these changes boost throughput, lower latency, and stabilize memory usage while offering broader Go‑specific best‑practice recommendations.
This article explains how Java implements locks—from the basic use of the synchronized keyword and Lock interface to the internal object header structures, bias, lightweight, and heavyweight lock upgrades, and the role of CAS and monitor objects in JVM concurrency control.
The article presents a scalable, two‑dimensional order state machine architecture that separates vertical business isolation via annotated StateProcessor classes from horizontal logic reuse through modular checkers and plugins, employing distributed locks, optimistic DB locking, and a registry to ensure extensible, consistent multi‑dimensional order processing.
This article introduces Java's Semaphore as a thread‑synchronization tool, explains its flow‑control use cases such as database connections and parking lots, provides a complete parking‑lot simulation code sample, and analyzes the underlying AQS‑based implementation including fairness, acquire/release mechanics, and auxiliary methods.
This article explains Redis's single‑threaded event loop, the impact of adding CPU cores, compares Redis with Memcached, discusses persistence suitability, synchronization methods, security concerns, request ordering, operation complexity, latency, and defines what constitutes a big key.
This article systematically explains why thread pools are needed, how to create them, the types of pools Executors can build, key parameters, underlying principles, rejection policies, blocking queues, core‑thread settings, pool states, thread reuse, the difference between submit() and execute(), and practical usage tips for Java developers.
This article explains the differences between user threads and daemon (background) threads in Java, demonstrates how to identify, create, and configure them—including thread pools—and discusses important considerations, priority effects, and typical use cases such as garbage collection.
This article explains how Kafka's producer uses a memory pool to reuse RecordBatch objects, detailing the allocation and deallocation mechanisms, lock handling, and conditions that prevent full garbage collection pauses, thereby improving throughput and resource efficiency.
This article examines the business context and collection workflow of a BOS‑integrated service, dissects the distributed lock logic and its execution sequence, and conducts a thorough structured code review that reveals logical, exception, non‑functional, and testability issues while offering concrete improvement recommendations.
This article analyzes a real‑world flash‑sale incident where a Redis distributed lock expired under high concurrency, leading to massive overselling, and presents safer lock implementations, atomic stock checks, and architectural improvements to prevent similar failures.
This article explains why local in‑memory locks fail in distributed environments, introduces the concept of distributed locks, and walks through five progressive Redis‑based lock implementations—bronze, silver, gold, platinum, and diamond—detailing their principles, code examples, advantages, and shortcomings.
This article explains the inner workings of Java thread pools, clarifies common misconceptions about core pool sizing, BlockingQueue behavior, concurrency calculation, and runtime factors such as GC, providing practical guidance and code examples for correctly configuring thread pools in backend systems.
This article explains Kotlin coroutine fundamentals, creation, launch and async usage, suspension functions, withContext, and compares coroutine-based implementations with RxJava in Android development, providing code examples and best‑practice guidance, including performance considerations and migration advice.
This article presents twelve fundamental Java concurrency interview questions, covering thread creation methods, their pros and cons, thread states, lifecycle, start vs run, termination, thread safety, differences between threads and processes, communication, yield vs sleep, and provides concise answers to help candidates demonstrate solid multithreading knowledge.
Through a whimsical first‑person narrative, the article explains three Java thread‑creation techniques—extending Thread, implementing Runnable (including anonymous and lambda forms), and using Callable with FutureTask—to illustrate their syntax, usage, and the ability to retrieve thread results.
This article explains the purpose and usage of Java's Semaphore class, demonstrates how it can be applied for rate limiting with real‑world analogies, provides a complete parking‑lot example with source code, and discusses fairness modes and additional Semaphore APIs.
This article explores Baidu C++ engineers' deep‑dive into performance optimization, covering memory‑access patterns, string‑buffer handling, protobuf merging, malloc strategies, job‑arena allocation, cache‑line effects, and modern memory‑order semantics to achieve multi‑fold speedups in large‑scale backend services.
This article explains MySQL's table, row, and page lock levels, describes next‑key, gap, and record locks, illustrates common deadlock scenarios with detailed SQL examples, and outlines InnoDB's lock acquisition and deadlock‑prevention strategies to help developers avoid concurrency issues.
This article explains Java thread pool fundamentals—including core parameters, task submission behavior, rejection policies, queue selection, thread factory usage, keep-alive settings—and provides practical guidance on determining optimal thread counts for I/O‑bound and CPU‑bound workloads.
The article examines Apache Commons‑Pool2’s object‑pool architecture, detailing its core interfaces (ObjectPool, PooledObjectFactory, PooledObject), the GenericObjectPool construction, FIFO/LIFO idle‑object deque management with lock‑based concurrency, borrowing and returning workflows, self‑protection features like abandonment detection, and the performance tuning needed for high‑concurrency environments.
This article provides a thorough collection of over 30 common Java HashMap interview questions, explaining its underlying data structures, hashing mechanisms, collision resolution, resizing, thread safety, and differences from related maps, along with detailed answers and code examples for each topic.
This article examines a real‑world incident where a Redis‑based distributed lock caused a 100‑bottle oversell of a scarce product, analyzes the root causes such as lock expiration and non‑atomic stock checks, and presents safer lock and stock‑validation solutions using Lua scripts and atomic Redis operations.
This article explains the concept of soft‑start in performance testing, presents Java implementations for both fixed‑thread and fixed‑QPS models, discusses error‑impact considerations, and provides practical code snippets to gradually ramp up load and improve measurement accuracy for high‑throughput services.
This article compares Apache Hudi, Apache Iceberg, and Delta Lake, examining their storage formats, platform compatibility, update performance, concurrency guarantees, and integration with lakeFS to help readers choose the most suitable solution for their data lake use case.
This article explains how to use java.util.Timer for one‑time and periodic task scheduling, covering constructors, instance methods, daemon‑thread behavior, handling past dates, negative delays, multiple tasks, and proper shutdown, with complete code examples and execution results.
