The article explains why ThreadLocalRandom should not be stored in a static field, demonstrates how using ThreadLocalRandom.current().nextX(...) avoids predictable random numbers, compares behavior between JDK 11 and JDK 19, and provides the proper usage pattern with code examples.
This article explains the step‑by‑step evolution of Redis‑based distributed lock implementations—from a simple SETNX approach to a robust solution using UUIDs, expiration, atomic Lua scripts, and finally Redisson’s high‑level lock API—illustrating common pitfalls and their fixes.
This article presents a complete Netty‑based TCP demo for IoT projects, detailing the project background, architecture, module layout, business flow, and in‑depth Java code examples—including a local queue, multithreaded processing, client creation, Redis locking, and SpringBoot integration—along with testing instructions and source links.
This article explains why time‑consuming business operations need a distributed lock, walks through using Redis as a lock with Spring AOP, details the lock‑acquire, timeout, and renewal mechanisms, provides full code examples, testing steps, and best‑practice recommendations for reliable concurrency control in Java back‑end services.
The article explains Java's new Virtual Thread (coroutine) feature, compares the traditional thread‑per‑request model with asynchronous and coroutine approaches, discusses Little's Law for scalability, and outlines the benefits and pitfalls of using coroutines in server‑side Java applications.
This article explores Java multithreading concepts, JVM safety tools, thread creation methods, coordination mechanisms, and practical scenarios such as parallel data aggregation, for‑loop conversion, map‑based processing, and multi‑threaded transaction handling, providing code examples and performance tips for backend developers.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock implemented with custom annotations, Spring AOP, and a scheduled thread pool that automatically extends lock expiration to avoid premature release.
This article explains Python's multiprocessing module, shows how to create and manage processes and process pools with clear code samples, and outlines common use cases, best practices, and pitfalls for efficiently handling CPU‑bound tasks.
This article explains how to protect time‑consuming business operations by using Redis as a distributed lock, designing a custom @RedisLock annotation, applying Spring AOP to intercept methods, handling lock acquisition, expiration, renewal via a ScheduledExecutorService, and releasing the lock safely after execution.
This article explains the four common Redis caching challenges—cache penetration, avalanche, breakdown, and data inconsistency—demonstrates their impact under high concurrency, and provides practical Java Spring Boot solutions including caching null objects, Bloom filters, distributed locks, random expiration, and delayed double‑delete strategies with full code examples.
Switching from single‑threaded synchronous code to multithreaded asynchronous execution can improve performance, but introduces nine major issues—including missing return values, data loss, ordering problems, thread‑safety, ThreadLocal anomalies, OOM risks, high CPU usage, transaction failures, and service crashes—each explained with Java examples and solutions.
This article explains why Tokio may discard asynchronous tasks when the thread pool is saturated and demonstrates how to use a bounded JoinSet to block task creation until resources become available, ensuring all tasks complete.
This article examines frequent mistakes when using Java thread pools—such as improper creation, unreasonable parameters, unreleased local pools, and unsafe concurrent operations—and provides detailed analysis, configuration guidelines, and best‑practice recommendations to prevent memory leaks, deadlocks, and performance issues.
This article walks through the step‑by‑step evolution of Redis‑based distributed lock implementations—from simple SETNX locking to atomic expiration, UUID‑based ownership, Lua‑scripted safe release, and finally using Redisson’s high‑level lock API—illustrating common pitfalls and robust solutions.
This article explains how the JVM optimizes locking through spin locks, adaptive spinning, lock elimination, and lock coarsening, and describes escape analysis techniques that enable stack allocation, scalar replacement, and synchronization removal, illustrated with Java code examples and diagrams.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock in Spring Boot, covering annotation design, AOP pointcut definition, lock acquisition and release, automatic lock renewal with a scheduled executor, and practical testing results.
This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.
Linux kernel synchronization requires protecting shared mutable state from concurrent access using primitives such as spinlocks, mutexes, read‑write locks, or lock‑less techniques like RCU, which copies data and waits for a grace period, each offering distinct performance, latency, and complexity trade‑offs.
This article explains three Java singleton implementations—double‑checked locking with volatile, static inner‑class holder, and enum singleton—detailing their thread‑safety, lazy initialization, and how they prevent issues such as instruction reordering, serialization, and reflection attacks.
The article explains Apache’s three processing models (prefork, worker, event), compares their resource usage with Nginx, and demonstrates how Nginx’s event‑driven, single‑threaded architecture achieves far higher concurrent connection capacity and better performance for web services.
This article explains the seven ways to create Java thread pools, categorizes them by ThreadPoolExecutor and Executors, and provides detailed code examples for fixed-size, cached, scheduled, single‑thread, work‑stealing pools, as well as custom thread factories and task result handling.
The article explains how Spring's @Async annotation works, compares synchronous and asynchronous calls, reviews the built‑in executors such as SimpleAsyncTaskExecutor, discusses their drawbacks, and provides detailed guidance on creating custom thread pools via AsyncConfigurer, AsyncConfigurerSupport, or a TaskExecutor bean, including code examples.
This article explains the Java synchronized keyword, its three usage forms, the underlying JVM object header and monitor structures, the lock acquisition process, and the progression from no lock through biased, lightweight, and heavyweight locks, illustrating how synchronization ensures thread safety.
The article explains that the 65,535 TCP port limit does not bound a Linux server’s concurrent connections, detailing how TCP connections are identified, the theoretical maximum of 2⁴⁸ connections for a server, and the practical constraints imposed by memory and file‑descriptor limits.
This article explains how Spring Boot relies on Tomcat's thread and connection settings, demonstrates how to configure these parameters, runs a practical test to observe request handling limits, and discusses the resulting concurrency problems and their root causes.
This article explains how TCP connections are identified, the theoretical limits for client (65,535) and server (up to 2^48) connections, and why practical concurrency is governed by system resources, port reuse, and server architecture rather than the raw port count.
This comprehensive guide walks Go developers through performance tuning fundamentals, recommended profiling tools, code-level optimizations, and real-world case studies, offering actionable insights to measure, diagnose, and improve CPU, memory, and concurrency efficiency in high‑throughput Go services.
This article explains how RocketMQ creates and manages threads, covering single‑thread creation via Runnable and Thread inheritance, the ServiceThread abstract class, ThreadPoolExecutor configuration, custom thread factories, and the importance of descriptive thread names for debugging.
This article explains Java's CompletableFuture API introduced in JDK 8, covering how to create asynchronous tasks with supplyAsync and runAsync, use various callback methods such as thenApply, thenAccept, thenRun, whenComplete, handle, and combine multiple futures with thenCombine, allOf, anyOf, providing code examples and execution results.
This article explains various ways to terminate a running Java thread, including using exit flags, interrupt(), deprecated stop()/suspend()/resume() methods, handling InterruptedException, while providing code examples and discussing the risks of forceful termination.
This article explains how Go implements its own goroutine scheduler within the runtime, demonstrates it with sample code, and details the GMP (Goroutine‑M‑Processor) model, its scheduling strategies, and the evolution from the earlier GM model.
This article explains the definitions and differences of QPS and TPS, describes concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, MAU, and outlines key considerations for system performance testing and capacity planning.
This article explains how the JVM improves concurrency performance through lock optimization techniques such as spin locks, lock elimination, lock coarsening, and escape analysis, illustrating each concept with code examples and discussing related optimizations like stack allocation and scalar replacement.
This article explains the definitions and differences between QPS and TPS, explores related concepts such as concurrency, throughput, PV, UV, DAU, MAU, and outlines practical methods for evaluating system performance and capacity planning.
This article explains various ways to terminate a running Java thread, comparing safe flag‑based exit, the deprecated stop/suspend/resume methods, and the recommended interrupt approach, while demonstrating how to detect interruption status, handle exceptions, and avoid common pitfalls with code examples.
This article explains the JVM object memory layout—including object header, instance data, and alignment padding—details the structure of the Mark Word and Klass Word, describes how monitors and the synchronized keyword work at the bytecode level, and covers lock states, inflation, bias revocation, and spin optimizations with practical code examples.
This article presents the architecture, technology choices, and practical implementation details of FairPushy—a Dart‑driven backend and Flutter dynamic‑update platform—covering server development, concurrency handling, ORM integration, automated build pipelines, and deployment strategies for seamless hot‑reloading of mobile applications.
The article introduces Java's ForkJoinPool for dividing large, compute‑intensive tasks into smaller subtasks, explains its suitability for performance testing scenarios such as high‑throughput QPS/RT data collection, and provides a complete Groovy‑based demo that defines a RecursiveTask, implements the compute method, and runs a sum calculation using a thread pool.
This article walks through a hands‑on Go RPC demo, explains the underlying server and client mechanisms, explores registration, HTTP handling, request processing, object pooling, and the gob codec, and clarifies why Go includes RPC alongside HTTP.
This article explains what a deadlock is, demonstrates a simple Java deadlock example with code, outlines the four necessary conditions, and introduces four practical tools—jstack, jconsole, jvisualvm, and jmc—for diagnosing and resolving deadlocks in Java applications.
This article demonstrates how to simulate high‑concurrency flash‑sale scenarios using SpringBoot, MySQL, and JMeter, and compares seven approaches—including lock‑based, AOP, pessimistic and optimistic locking, and queue‑based solutions such as BlockingQueue and Disruptor—to prevent overselling and improve performance.
This article explains how Go’s fast compilation, lightweight runtime, built‑in concurrency, strong type safety, and cross‑platform compatibility make it a compelling choice for building scalable, high‑performance backend services, and provides practical code examples to get started quickly.
This article explains the differences and similarities between Java's ObjectMonitor and the AbstractQueuedSynchronizer (AQS) implementations of heavyweight locks, covering their internal data structures, waiting queues, lock acquisition order, and how synchronized interacts with wait/notify mechanisms.
This article demonstrates how to convert multiple asynchronous queries into a synchronous response using Java's CompletableFuture, providing step‑by‑step code examples in both Java and Groovy, explaining execution flow, timeout handling, and practical considerations for WebSocket‑like scenarios.
This article analyzes the overselling problem in high‑concurrency flash‑sale scenarios, demonstrates seven concrete solutions—including improved locks, AOP locks, pessimistic and optimistic database locks, and queue‑based approaches using BlockingQueue and Disruptor—provides full SpringBoot code, JMeter test results, and practical recommendations for reliable stock reduction.
This article explains why tasks submitted to a Java ThreadPool via submit do not print exceptions, how to retrieve them using Future.get(), and presents three practical solutions—including try‑catch, Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably capture and process thread pool exceptions.
This article explores why simple @Transactional locking can still cause product overselling under high concurrency, then presents seven detailed Java/SpringBoot solutions—including improved locking, AOP, pessimistic and optimistic database locks, and queue‑based approaches—complete with code, performance tests and best‑practice recommendations.
This article explains why client information stored in ThreadLocal becomes unavailable after switching a single‑threaded search service to multithreading, analyzes the underlying ThreadLocal and InheritableThreadLocal mechanisms, and provides two practical solutions—passing the context manually or using InheritableThreadLocal—to avoid the upgrade‑prompt bug.
This article clarifies the common misconception that Redis is purely single‑threaded by detailing its single‑threaded network I/O model, the evolution of multithreading support across versions, the client‑server request flow, and the underlying Reactor patterns that enable efficient concurrency.
This article introduces the Disruptor library, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategy, and provides a complete eight‑step Spring Boot example with code to create, publish, and consume high‑throughput messages in Java.
This article explains the internal mechanisms of Java's ConcurrentHashMap, covering its constructors, element insertion via put and putVal, the sizeCtl variable, treeification of bins, counting operations, and the complex multi‑threaded resizing process, with detailed code examples.
This article walks through building a minimal Go HTTP server, explains how ListenAndServe manages connections, details the internal accept‑serve loop, shows request handling, routing rules, and customization hooks, providing clear code examples and diagrams to demystify Go’s built‑in web server.
This article analyzes why simple @Transactional and lock annotations still cause overselling in flash‑sale scenarios, then presents seven backend solutions—including improved controller locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches with BlockingQueue and Disruptor—along with code samples and JMeter test results.
This article presents a Go-based MySQL-to-MySQL data synchronization solution built on go-mysql-transfer, detailing its architecture, multi‑threaded design, binlog handling, DDL/DML ordering, and code implementation for reliable, ordered, and fault‑tolerant replication.
This article dissects Go’s select statement, explaining its I/O multiplexing purpose, compile‑time transformation via walkSelect and walkSelectCases, and the multi‑stage runtime algorithm in runtime.selectgo that handles various case patterns, lock ordering, polling randomness, and channel blocking behavior.
This article explains the concept of distributed locks, illustrates real‑world scenarios such as concurrent ATM transactions, and details how to implement reliable distributed locking with Redis using TTL keys, SETNX, Lua scripts, lock renewal, high‑availability considerations, and the RedLock algorithm.
This article explains why common Redis‑based flash‑sale demos that rely on WATCH transactions, distributed locks, or Lua scripts are unreliable, and presents a simple, lock‑free solution using Redis list operations (LPUSH/RPOP) with Spring Boot's StringRedisTemplate, including full Java code and usage examples.
This article explains Java's AbstractQueuedSynchronizer (AQS) framework, covering its MESA monitor model, entry and condition wait queues, exclusive and shared lock acquisition and release, and how core concurrency utilities like ReentrantLock, ReadWriteLock, CountDownLatch, Semaphore, ThreadPoolExecutor, and CyclicBarrier are built upon it.
The article explains how to merge multiple user queries into a single batch request using a queue, scheduled thread pool and CompletableFuture in Spring Boot, thereby reducing database connections and improving resource utilization while handling high‑concurrency scenarios.
This article explains Spring's TaskExecutor and TaskScheduler abstractions, their various implementations, how they decouple threading and scheduling from the deployment environment, and provides practical code examples for configuring and using them in Java applications.
This article explains how to batch multiple cluster endpoint requests in Go by using a token‑based queue and concurrent workers, dramatically reducing load on the registration center while requiring minimal changes to existing code.
The article introduces Pond, a high‑performance Python object‑pool library that reduces memory consumption and GC pressure by reusing objects, explains its design components, automatic eviction strategy, thread‑safe borrowing and returning mechanisms, and provides detailed usage examples with code snippets.
This article explains why common Redis‑based flash‑sale demos using WATCH or distributed locks are unreliable, and presents a simple, atomic solution that leverages Spring Boot's StringRedisTemplate with Redis list operations (LPUSH/RPOP) to achieve high‑concurrency秒杀 without explicit locking.
This article introduces Java's Disruptor framework as a high-performance, lock-free queue, explains its core components such as RingBuffer, Sequencer, and WaitStrategy, provides sample code for producers and consumers, and discusses how it avoids lock contention and false sharing.
This article introduces asynchronous programming concepts in Java, explaining the shift from synchronous to asynchronous execution, and demonstrates practical implementations using raw threads, ThreadPoolExecutor, Future, FutureTask, CompletableFuture, and Spring's @Async annotation, along with event handling and message queue integration for high‑throughput systems.
A low‑load performance test compares three ways of selecting an array index—using Math.random(), a sequential int counter, and AtomicInteger—revealing that the random‑number approach consumes significantly more CPU while AtomicInteger spikes memory usage under higher loads.
This article breaks down nine essential techniques—ranging from faster CPU execution and effective caching to reducing interrupts, memory copies, and lock contention—to help developers systematically improve software performance across hardware and software layers.
This article explains the design and C implementation of a five‑level hierarchical timing wheel, covering its data structures, pointer handling with bitwise operations, timer insertion, modification, deletion, cascade processing, and a demo program that highlights blocking behavior of long‑running timer callbacks.
The article explains Go’s channel implementation as a lock‑protected FIFO queue composed of a circular buffer, send and receive wait queues, detailing creation, send/receive mechanics, closing behavior, a real‑world memory‑leak example, and why this design offers safe, performant concurrency comparable to mutexes.
The article explains Java’s concurrency mechanisms, detailing how threads communicate and synchronize via shared memory and the Java Memory Model (JMM), describing atomic actions, the MESI cache protocol, and key principles such as happens‑before, visibility, atomicity, and ordering.
This article delves into the internal design and execution of Java 8 lambda expressions, dissecting the Stream API pipeline—from source creation through intermediate operations like map and filter to terminal actions such as collect and sum—while illustrating each step with concrete code examples.
This article compares Java’s HttpClient timeout implementation with Go’s built‑in HttpClient, explains Go’s Context‑based timeout mechanism, walks through the underlying source code, and shows why Java cannot easily replicate the same approach due to differences in concurrency primitives.
An operation team discovered that QR code redirects returned 404 due to expired access tokens, traced to SimpleDateFormat’s thread‑unsafe parsing causing incorrect expiration dates; the article analyzes the root cause, demonstrates failing multithreaded tests, and presents four thread‑safe alternatives including local instances, synchronization, ThreadLocal, and Java 8’s DateTimeFormatter.
This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.
This article explains Go's context package, covering its motivation, core design (interface, implementations, methods), detailed source‑code analysis, and practical recommendations for safe and effective usage in concurrent applications.
This article explains a Java technique for limiting asynchronous task execution to a fixed queries‑per‑second rate using a Semaphore‑based thread pool, a LinkedBlockingQueue, and a daemon thread that manages task dispatch, shutdown, and idle waiting.
This article compiles a series of frequent Go programming pitfalls—ranging from incorrect use of unsafe.Sizeof and variadic any parameters to slice expansion, pointer handling, closure capture, concurrency bugs, and serialization quirks—providing concrete code examples and safe alternatives to help developers write more reliable Go code.
This article explains why creating threads repeatedly wastes resources, introduces Java's ExecutorService thread pool, details its configuration parameters, demonstrates how to create and use fixed thread pools with Runnable and Callable tasks, shows proper shutdown, and highlights common pitfalls with Future.get.
The article examines three approaches to handling inventory deduction in e‑commerce—single‑field MySQL, sharded MySQL rows, and Redis incrby—analyzes their concurrency drawbacks, and presents a robust Redis‑Lua script solution with distributed locking and Java implementation details.
This article explains MySQL's three concurrency types—read‑read, read‑write, and write‑write—describes how InnoDB uses shared/exclusive locks, MVCC snapshot reads, and ReadView metadata to ensure transaction isolation, and provides practical examples and lock‑based solutions for avoiding update loss.
This article examines how ScheduledThreadPoolExecutor can lose exception information and stop rescheduling periodic tasks when a task throws an exception, by walking through the source code flow, the runAndReset logic, and the resulting behavior.
This article explains how to implement a Redis-based distributed lock in Spring Boot using custom annotations, AOP interception, and a scheduled executor to automatically renew lock expiration, providing a complete design, code examples, and testing guidance for handling long-running operations safely.
This article explains how to use Java's java.util.concurrent.Semaphore together with a fixed-size thread pool to enforce a precise QPS limit for asynchronous tasks, providing API details, implementation steps, and a complete test example.
This article systematically examines ten typical pitfalls encountered when converting arrays to lists, performing add/remove operations, using subList, handling memory consumption, and working with thread‑safe collections such as CopyOnWriteArrayList in Java, and provides concrete code‑level solutions and performance recommendations.
This article explains the design and implementation of a Redis‑based distributed lock using Spring AOP, covering annotation creation, pointcut definition, lock acquisition, automatic renewal via a scheduled thread pool, error handling, and testing to ensure safe concurrent access to critical business data.
This article explains why locks are needed in Java, describes the fundamentals of volatile and synchronized, details the monitor‑based implementation of synchronized, introduces CAS operations, and outlines advanced lock mechanisms such as biased, lightweight, lock coarsening, elimination, and the AbstractQueuedSynchronizer framework.
This article explains the different delay and periodic task types supported by Java's ScheduledThreadPoolExecutor, details its constructor parameters and default settings, and highlights common pitfalls such as exception loss, inaccurate scheduling, and improper core pool size configuration.
This article explains the internal workings of Java's ThreadLocal, including the ThreadLocalMap structure, weak reference handling, lazy initialization, and common pitfalls such as memory leaks in thread pools, and provides best‑practice guidelines for safe usage.
This weekly newsletter curates top community tech shares, featuring MySQL 8.0 updates, database localization insights, concurrency consistency strategies, a new SQL auditing tool release, development progress, upcoming plans, and invites community feedback on DBLE, DTLE, SQLE, and TXLE middleware.
This article explores Rust's rise in systems programming, detailing its strengths such as safe concurrency, modern language design, and strong compiler feedback, while also highlighting challenges like a steep learning curve, complex async model, and low‑level memory management concerns.
The article explains why transaction isolation is needed, describes common concurrency problems such as lost updates, dirty reads, non‑repeatable reads and phantom reads, outlines the ACID properties of a transaction, and details MySQL's four isolation levels with their effects and default settings.
This article explains how Go’s goroutine scheduler works, covering the fundamentals of OS thread scheduling, the transition from the old G‑M model to the modern G‑P‑M model, pre‑emptive scheduling strategies, lifecycle details, practical debugging tools, and performance‑related design choices.
This article explains the seven essential configuration parameters of Java's ThreadPoolTaskExecutor, covering thread creation, core and maximum pool sizes, keep‑alive policies, work queues, thread factories, rejection handlers, and practical usage tips with code examples and common pitfalls.
This article demonstrates how to create a perpetual multithreaded Java task using a custom thread‑pool utility, supports concurrent execution of multiple long‑running jobs, and implements an elegant shutdown that drains remaining work before terminating.
This article examines Rust's rapid rise, its safety‑focused design versus C/C++'s speed emphasis, real‑world adoption by major tech firms, and the ongoing debate about whether Rust can eventually supplant C and C++ for system‑level development.
This article introduces Java 19's virtual threads, compares their performance and scheduling with traditional platform threads and Go goroutines, provides practical code examples, benchmark results, and migration guidelines, and explains the underlying M:N scheduling mechanisms that make virtual threads more efficient for high‑concurrency, I/O‑bound workloads.
This article explains the fundamentals of Java thread pools, covering their purpose, construction parameters, execution process, worker reuse, task retrieval with timeout, lifecycle states, shutdown methods, monitoring techniques, and practical guidelines for customizing thread pools in real-world projects.
An in‑depth examination of Go’s compact context package reveals its core interface, internal implementations like emptyCtx, cancelCtx, timerCtx, and valueCtx, the propagation and cancellation mechanisms, and practical design patterns, concluding with essential best‑practice guidelines for passing, canceling, and using context values safely.
This article explains how HikariCP's lock‑free ConcurrentBag manages database connections using ThreadLocal caches, a CopyOnWriteArrayList, AtomicInteger waiters, and a SynchronousQueue, and walks through the key code for borrowing and returning connections to improve Java multithreaded performance.
This article explains Java parallel streams, shows how to replace manual thread handling with a one‑line parallelStream call, benchmarks its performance, discusses cases where it slows down, highlights shared‑variable hazards, and provides practical guidelines for effective use.
