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.
This article explains the fundamentals of Java threading, covering process vs thread differences, context switching, daemon and user threads, thread states, synchronization mechanisms, interruption handling, and deadlock detection with concrete code examples and visual illustrations.
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 explains the Java Memory Model, distinguishes main memory from thread-local memory, and demonstrates how visibility, ordering, and atomicity affect concurrent programs through code examples, volatile and synchronized keywords, double‑checked locking, and the Happens‑Before rules.
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.
This article introduces Quartz, a Java job‑scheduling library, explains its core components (Job, Trigger, Scheduler), provides step‑by‑step Maven demos, shows how to integrate it with Spring Boot, configure persistence, manage concurrency, and handle advanced features like cron expressions and calendar exclusions.
The article explains how converting a serial RPC call layer to an asynchronous parallel model can cause thread pool exhaustion and hunger lock when tasks depend on each other, demonstrates the issue with Java code, and provides practical strategies such as using separate pools or CompletableFuture to avoid the problem.
This article explains Java multithreading safety issues, demonstrates synchronized methods, blocks, static methods, mutex locks, deadlock scenarios, and the differences between wait() and sleep() with clear code examples and analysis of their effects on thread execution.
Learn how Go's lightweight goroutines work, why unlimited spawning can cause panics, and practical techniques—using sync.WaitGroup, buffered channels, and worker pools—to limit concurrent goroutine numbers safely and efficiently while preserving program correctness and performance.
This article explains the difference between synchronous and asynchronous calls, demonstrates a synchronous Task example, shows how to convert it to asynchronous execution with Spring Boot's @Async annotation, and introduces Future-based callbacks to coordinate concurrent tasks and measure total execution time.
The article explains how to achieve million‑level concurrency in Java by focusing on three fundamental problems—task division, synchronization, and mutual exclusion—using real‑world analogies, diagrams, and concrete code examples to illustrate proper multithreaded design.
This article explains Java thread‑safety concepts, classifies five safety levels from immutable to thread‑hostile, and details synchronization techniques—including mutual exclusion, non‑blocking CAS, and no‑sync approaches like reentrant code and thread‑local storage—to help developers write safe concurrent code.
This article explores the QPS threshold required to expose thread‑unsafe operations such as i++ by designing a SpringBoot service, running controlled load tests with both fixed‑thread and precise‑QPS models, and presenting detailed results that show how error rates increase with higher request rates.
The article explains how to build reliable distributed locks using Redis, Zookeeper, and etcd, describing the essential concepts of mutual exclusion, safety, and liveness, showing code examples, highlighting common issues, and comparing each solution's advantages and drawbacks.
This article explores Go language closures and their delayed binding behavior through seven illustrative cases, detailed experiments, and code examples, clarifying value vs reference passing, goroutine timing effects, and practical pitfalls for developers.
This article explains the key Lucene classes involved in document indexing, outlines the end‑to‑end write workflow—including preUpdate, obtainAndLock, updateDocument, exception handling, and post‑update flush logic—and discusses the strategies and thresholds that control when in‑memory buffers are flushed to disk.
By analyzing thread preemption on low‑end iPhones, this article demonstrates how selecting appropriate GCD queue QoS levels—favoring Utility or Background over User‑Initiated—reduces main‑thread contention, improves launch screen rendering by ~100 ms, and accelerates message list first‑load by up to 1.5 s without altering business logic.
This article explains why Redis, originally designed as a single‑threaded in‑memory database, introduced a multithreaded network layer in version 6.0, covering the historical design, the limits of CPU vs I/O utilization, the role of I/O multiplexing, and the benefits and drawbacks of the new model.
This article explains how Java's ReentrantLock works, detailing the role of the AbstractQueuedSynchronizer framework, the lock's internal architecture, the FIFO wait‑queue implementation, lock acquisition and release processes, and how these mechanisms avoid the herd effect in multithreaded environments.
This article explains thread safety in Java by detailing how the synchronized keyword and various Lock implementations work, covering their underlying JVM mechanisms, lock upgrade paths, optimizations like biased and lightweight locks, and practical differences between synchronized, ReentrantLock, and ReadWriteLock.
This article explains the hardware memory hierarchy, CPU multi‑level caches, cache coherence protocols, and how Java’s memory model abstracts these concepts to ensure thread safety, covering local and main memory, synchronization primitives, and the three core properties of atomicity, visibility, and ordering.
An interview with Rust creator Graydon Hoare explores the language's origins, its emphasis on speed, memory safety and concurrency, its adoption by major tech firms, and his perspective on the current state and future challenges of system programming security.
This article explains the sliding window rate‑limiting algorithm, its advantages over fixed windows, and provides a detailed step‑by‑step implementation using Sentinel’s data structures, including window partitioning, bucket management, concurrency handling, and calculation of request counts within a moving time interval.
This article explains how Java's synchronized keyword works at the JVM level, detailing monitorenter/monitorexit bytecode, the role of object monitors, differences between synchronized methods and blocks, and compares its behavior and performance with explicit Lock implementations such as ReentrantLock, including code examples and practical considerations.
This article explains the design and implementation of a timestamp‑based log replay engine that replays HTTP traffic using Java's DelayQueue, thread pools, and custom data structures, and provides performance test results demonstrating its ability to handle hundreds of thousands of requests per second.
This document lists the complete set of lecture PDFs, videos, and supplemental files for a Java backend development curriculum, covering data structures and algorithms, Spring Framework, JVM fundamentals, concurrency, cloud native concepts, and interview-focused topics across eleven chapters.
This article introduces Python's asyncio library, explains the fundamentals of coroutines, tasks, and the event loop, compares synchronous and asynchronous code execution with practical examples, and demonstrates how asynchronous programming can significantly improve performance in I/O‑bound scenarios.
