This article explains what the Python Global Interpreter Lock (GIL) is, why it was introduced, how it affects multithreading and multiprocessing, and discusses recent efforts to make the GIL optional and eventually remove it from CPython.
This article explains how to identify and resolve multithreaded deadlocks in Linux C++ programs by using shell utilities such as ps and top for initial diagnosis, then attaching GDB to inspect thread stacks and pinpoint the exact lock contention causing the freeze.
This article explains two design approaches for handling test data in a multithreaded performance testing engine, compares their trade‑offs, and provides complete Java code for data aggregation, statistical analysis, TPS calculation, and refactoring the tool for cleaner extensibility.
This article explains the purpose of Java's Thread.start() method, demonstrates what happens when it is invoked twice, shows the resulting IllegalThreadStateException, and provides a detailed analysis of the start() source code to clarify the thread lifecycle.
This article walks through designing and implementing a Java multithreaded execution class for performance testing, covering thread‑pool creation, task coordination with CountDownLatch, start/stop control, and a complete demo that runs concurrent tasks with timed logging.
The article explains Java’s ReentrantLock implementation, contrasting fair locks that queue threads in request order with non‑fair locks that allow immediate acquisition, detailing the internal Sync, FairSync and NonfairSync classes, lock/unlock mechanisms, performance trade‑offs, and guidance on selecting the appropriate lock type.
This article provides a comprehensive overview of Jemalloc, covering its architecture, memory allocation fundamentals, performance comparison with ptmalloc and tcmalloc, practical optimization cases across web, database, and big‑data workloads, and detailed configuration guidelines to improve memory efficiency and multithreaded performance.
This article explains the design and implementation of a flexible, extensible Java multithreaded task class for performance testing, covering the choice of Runnable over Thread, execution control mechanisms, data collection methods, and sample abstract code illustrating before, test, and after lifecycle hooks.
This article introduces Web Workers as an HTML5 API for running background threads, explains their creation and communication mechanisms, provides a complete Fibonacci calculation demo with full source code, and discusses common pitfalls such as asynchronous postMessage behavior, data serialization, and proper thread termination.
This article examines KeyDB, a Redis fork that adds multithreading, detailing its thread architecture, connection management, fastlock synchronization mechanism, and active‑replica features, while illustrating how these innovations improve performance and scalability compared to the original single‑threaded Redis.
This article explains how to improve performance of massive IN‑list database queries in Java by defining custom Spring AOP annotations that automatically split the parameter list, execute the sub‑queries concurrently in a thread pool, and merge the results using a configurable return‑handling strategy.
This article explains the concept of deadlocks in concurrent programming, outlines the four necessary conditions, examines common causes in Java, provides a runnable code example, and presents practical prevention, avoidance, detection, and recovery techniques to keep multithreaded applications running smoothly.
This chapter explains how to build a Java-based performance testing engine by dissecting common testing requirements, illustrating queue and throttling models through a supermarket analogy, and presenting thread‑based and TPS‑based designs with code examples and future extensions.
This article explains what unfair locks are, why they can improve throughput compared to fair locks, provides a Java ReentrantLock example with code, describes the internal acquisition process, and outlines typical high‑concurrency scenarios where unfair locks are advantageous.
Redis has introduced a multithreaded query engine that dramatically lowers latency and multiplies throughput for vector‑based retrieval, enabling real‑time RAG applications to approach the 100 ms response target while scaling vertically to billions of documents.
ThreadLocal provides a simple yet powerful way to give each thread its own independent variable, eliminating shared-state conflicts; this guide explains its underlying mechanism, creation methods, basic get/set operations, a complete example with console output, and important usage considerations such as potential memory leaks.
This article describes how to dramatically speed up the import of 60,000+ XML records into MySQL by analyzing the original environment, measuring baseline performance, and applying a series of backend optimizations—including MySQL batch mode, rewriteBatchedStatements, multithreaded asynchronous writes with Disruptor, and XML parsing improvements—ultimately cutting the total runtime from five minutes to just a few seconds.
This article provides a comprehensive overview of Google’s TCMalloc memory allocator, detailing its three‑level cache architecture, allocation and reclamation strategies, installation methods, configuration options, and performance advantages over other allocators in C++ backend, game, and database applications.
This article explains a divide‑and‑conquer method that splits massive search‑log files, uses multithreaded hashing to count keyword frequencies, and applies a min‑heap to efficiently retrieve the top‑100 most frequent search terms for SEO and recommendation tasks.
This article explains how to improve PostgreSQL IN‑query performance in Spring Boot applications by splitting large IN parameter lists into smaller batches, executing them concurrently with a custom AOP annotation, and merging the results, providing a reusable annotation‑driven solution for high‑throughput backend services.
The article explains how Redis, a high‑performance key‑value store, can leverage multithreading for I/O operations, background tasks like UNLINK, and jemalloc memory‑management threads, providing configuration examples and Python code to improve performance in high‑concurrency scenarios while noting the associated CPU cost.
This article walks through a real‑world case of importing over 60,000 XML rows into MySQL, profiling the initial 300‑second runtime, and applying a series of optimizations—including JDBC batch processing, rewriteBatchedStatements, multithreaded asynchronous writes with Disruptor, and MySQL tuning—to achieve a final import time of around 4 seconds while managing memory usage.
This article explains the purpose, basic methods, best‑practice usage, and typical scenarios of Java's CountDownLatch utility, providing code examples and a comparison with Thread.sleep to help developers synchronize multiple threads effectively.
This article explains how to print numbers from 1 to 100 with two Java threads—one handling odd numbers and the other even numbers—by first using a synchronized block with wait/notify and then by employing Semaphore for thread coordination.
This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the parameter list, executing the sub‑queries concurrently with a custom Spring AOP annotation, and merging the results using a configurable thread pool and return‑handling strategy.
This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the list, executing sub‑queries in parallel using a custom Spring AOP annotation, and merging the results with a configurable handler, providing a reusable solution for Java backend services.
This article introduces Java's java.util.concurrent.atomic package, detailing the core atomic classes—AtomicBoolean, AtomicInteger, AtomicLong, and LongAdder—including their constructors, key methods, typical use cases, and performance considerations in high‑concurrency scenarios for developers seeking efficient thread‑safe operations.
This article explains the Java java.util.concurrent.locks.Lock interface and its ReentrantLock implementation, detailing the advantages of reentrancy, interruptibility, and timeout features, and provides practical code examples for blocking, interruptible, and timed lock acquisition along with best‑practice recommendations.
This article explains C++11’s memory model and atomic types, demonstrating how lock‑free concurrency, memory ordering, and synchronization primitives such as fences can be used to achieve high‑performance, race‑free multithreaded code for demanding backend systems like game servers.
By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.
Learn how to use Python to scrape hero equipment data from the King of Glory website, download images via multithreaded requests, and automatically generate comprehensive Markdown and Excel reports, complete with code snippets and troubleshooting tips for a seamless data extraction workflow.
Swoole v6.0.0 introduces multithreaded mode, new thread classes and synchronization primitives, iouring‑based asynchronous file I/O, numerous bug fixes, kernel optimizations, and deprecations, providing developers with enhanced performance, richer APIs, and broader platform compatibility for high‑concurrency PHP applications.
This article explains three common ways to create multithreaded Java programs—extending Thread, implementing Runnable, and using Lambda expressions—providing step‑by‑step instructions, code samples, console output, and a summary of each method’s advantages and appropriate use cases.
This article explains the purpose, typical usage scenarios, and provides concrete code demonstrations of Java's CountDownLatch and CompletableFuture, comparing their synchronization versus asynchronous capabilities and guiding developers on selecting the appropriate tool for effective multithreaded programming.
This article introduces the basics of Java multithreading concurrency, explains the difference between concurrency and parallelism with a supermarket analogy, and details thread pool creation, usage, and customization through analysis of ThreadPoolExecutor source code.
This article explains the concept of spin locks, compares them with mutexes, shows how to use the pthread API and C++ atomic_flag to implement them, outlines suitable scenarios, highlights CPU‑usage pitfalls, and provides practical code examples.
This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads, summarizes multithreading fundamentals, presents performance‑critical code examples, and discusses JVM memory, locking, middleware, and various optimization techniques for backend systems.
This article walks through Spring Boot 3.2.5 enhancements including multithreaded bean initialization, the new @Fallback annotation, handling duplicate bean names, RestClient.create(URI) usage, header binding to records, expanded task‑scheduler metadata, and a host of other backend improvements.
This article demonstrates how to boost the insertion speed of over two million records in a PostgreSQL database by configuring a Spring Boot ThreadPoolTaskExecutor for multithreaded batch processing, detailing the setup, code implementation, performance testing, and analysis of results.
The article examines CPython 3.13’s new free‑threading mode, its impact on the Global Interpreter Lock, benchmark results using a PageRank example, and practical multithreaded and multiprocessing implementations to show how performance can dramatically improve on modern multicore CPUs.
This article explains how to dramatically speed up MyBatis-Plus batch inserts by enabling the rewriteBatchedStatements JDBC property, creating custom batch insert/update methods, and applying multithreading, providing code examples, performance test results, and practical recommendations for handling large data synchronizations.
This article provides a comprehensive overview of POSIX threads, covering their architecture, creation, synchronization, attributes, scheduling policies, advantages, drawbacks, and real‑world examples such as mutex protection, barrier synchronization, and a cross‑platform network server implementation.
This article explains why MyBatis-Plus's saveBatch() can be slow for large data sets, shows how enabling rewriteBatchedStatements in the JDBC URL dramatically speeds up inserts, and demonstrates custom batch insert/update methods and multithreaded execution to further improve performance, complete with code examples and test results.
This article analyzes why Spring MVC fails to retrieve request header fields in multithreaded scenarios, explains the underlying ThreadLocal storage mechanism, critiques a common but flawed solution, and presents reliable approaches using CountDownLatch, manual RequestContextHolder propagation, and request caching to ensure header availability across threads.
This article explains common multithreading problems such as race conditions, deadlocks, resource contention, and data consistency issues, and provides Python code examples that demonstrate synchronization techniques, lock ordering, connection pooling, thread pools, and transaction management to ensure correct and stable concurrent execution.
Python's Global Interpreter Lock (GIL) serializes thread execution to protect memory, but in today's multicore era it creates performance bottlenecks; this article explains what the GIL is, why it exists, its impact on multithreading, and how multiprocessing can bypass its limitations.
This article outlines essential Python web‑crawling techniques—including basic GET/POST requests, proxy usage, cookie management, header spoofing, captcha handling, gzip compression, and multithreaded fetching—to help developers build efficient and robust crawlers.
This article provides a thorough introduction to the GNU Debugger (GDB), covering its core capabilities, startup methods, compilation requirements, a wide range of debugging techniques—including breakpoints, memory inspection, disassembly, reverse execution—and detailed guidance for multithreaded debugging on Linux systems.
This article outlines essential Python web‑scraping techniques, covering basic GET/POST requests, proxy usage, cookie handling, header manipulation to mimic browsers, simple captcha solutions, gzip compression handling, and multithreaded crawling with a thread‑pool template, providing practical code examples for each step.
This article provides a comprehensive guide to Java's volatile keyword, covering its pronunciation, core features such as visibility, lack of atomicity, and instruction reordering prevention, the Java Memory Model, cache‑coherence mechanisms, practical code examples, and best‑practice scenarios like double‑checked locking and when to prefer volatile over heavier synchronization constructs.
This article explains the structure and operation of modern CPU multi‑level caches, the write‑back caching policy, cache‑coherence mechanisms, atomic operations, and various memory‑ordering models in C++ multithreaded programs, providing detailed concepts, hardware and software solutions, and practical code examples.
This article explains the Singleton design pattern, compares lazy and eager implementations in Java, discusses thread‑safety issues with double‑checked locking, presents complete code examples, and outlines the advantages, disadvantages, and appropriate use‑cases for singletons.
This article explains how to correctly manage transactions across multiple threads in a Spring application by using manual SqlSession control, providing utility methods for list partitioning, thread‑pool configuration, and example code that demonstrates both failing and successful transaction scenarios.
This article explains Java’s synchronized keyword, covering its usage on methods and blocks, the underlying object header and monitor structures, and the lock‑upgrade process from no lock through biased, lightweight, and heavyweight states, illustrated with code samples and diagrams.
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.
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.
Redis has launched a multi‑threaded query engine that vertically scales its in‑memory database, dramatically increasing query throughput and lowering latency for vector similarity searches, thereby addressing the performance demands of real‑time retrieval‑augmented generation in generative AI applications.
Redis has introduced a multithreaded query engine that dramatically boosts throughput and lowers latency for vector searches, enabling scalable, real‑time retrieval‑augmented generation (RAG) workloads while preserving the low‑latency performance of its core in‑memory database.
This article provides a comprehensive overview of Java's ConcurrentHashMap, explaining its purpose, underlying lock‑segmentation and CAS mechanisms in JDK 7 and JDK 8, demonstrating usage with sample code, and outlining scenarios where it delivers high‑performance thread‑safe map operations.
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 how to build high‑concurrency systems by analyzing single‑machine hardware and code optimizations, clarifying multithreading versus asynchronous methods, and then scaling horizontally and vertically with caching, partitioning, and distributed inventory management to achieve stable, performant services for large‑scale e‑commerce workloads.
This article explains hyper‑threading fundamentals, distinguishes physical, logical, and CPU cores, shows how to query CPU topology on Linux, introduces the concept of CPU affinity, demonstrates using the taskset command and related syscalls, and provides C API examples for setting process and thread affinity.
An in-depth guide to Python's queue module, covering thread-safe queue classes, their usage in multithreaded programming, common methods like put, get, task_done, join, and practical code examples demonstrating producer-consumer patterns and bounded queues.
This article analyzes the UIDictationConnection crash on iOS 16 and later, explains the EXC_BAD_ACCESS (SIGSEGV) cause, walks through assembly‑level stack inspection, and provides a thread‑safe locking solution with runtime hooks to prevent the wild‑pointer failure.
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 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.
This article demonstrates how to boost the insertion speed of over two million records by using Spring Boot with MyBatis‑Plus, a ThreadPoolTaskExecutor for multithreaded batch inserts, and detailed performance testing that shows a reduction from 5.75 minutes to 1.67 minutes.
Multithreaded programming splits tasks across logical and hardware threads to exploit multicore CPUs, requiring careful use of synchronization primitives such as mutexes, read‑write locks, condition variables, and lock‑free atomics, while avoiding pitfalls like race conditions, deadlocks, and false sharing for correct, high‑performance software.
This article demonstrates how to implement a high‑performance file upload system using Vue's Element Plus component on the frontend and Spring Boot on the backend, comparing single‑row inserts, batch inserts, and a multithreaded producer‑consumer approach to dramatically reduce MySQL insertion time.
This article explains how Redis achieves extremely high throughput—over 800 k QPS for simple commands and up to 1 M QPS with pipelining—through its C implementation, in‑memory data store, single‑threaded event loop, I/O multiplexing, and optional multithreaded I/O introduced in later versions.
This article explains how Redis achieves tens of thousands of QPS on average hardware, breaks down the technical reasons behind its speed—including C implementation, in‑memory design, epoll‑based I/O multiplexing, and a single‑threaded event loop—while also detailing the evolution to multithreaded I/O in later versions.
Swoole v6.0 introduces multithreaded coroutine support, async file I/O via io_uring, new thread‑related classes, upgraded Boost Context, numerous bug fixes and kernel optimizations, expanding PHP’s capabilities beyond traditional web workloads to high‑performance networking, game servers, and micro‑services.
This article explains how using a shared class attribute to store open ports in a Python security‑testing framework can cause data contamination across threads, demonstrates the problem with example code, and presents three solutions—reinitializing the attribute, using contextvars, and employing threading.local—to ensure thread‑local isolation and accurate port scanning.
The article explains how Redis achieves high QPS by using an in‑memory, single‑threaded event loop for simple commands, leverages I/O multiplexing (epoll/select/kqueue) and optional multi‑threaded I/O for heavy operations, and outlines its evolution from a pure reactor model to a hybrid multi‑threaded architecture.
This article presents a comprehensive guide to designing and implementing a Java‑based MySQL large‑table migration tool using microservice architecture, multiple design patterns, multithreading, custom logging, and flexible migration modes, complete with code snippets, repository links, and deployment considerations.
This article demonstrates how to boost the insertion speed of over two million records by configuring a Spring Boot ThreadPoolTaskExecutor for multithreaded batch inserts, detailing the setup, code implementation, performance testing, and analysis of optimal thread counts.
This guide explains Python's multithreading and multiprocessing concepts, compares thread pools and process pools, provides practical code examples for task execution and file downloading, and offers best‑practice advice for efficient concurrent programming.
The article explains a bug in Java's ConcurrentHashMap.computeIfAbsent that can cause recursive updates and infinite loops, leading to CPU spikes, and shows that newer Java versions throw an IllegalStateException while recommending avoiding nested computeIfAbsent/putIfAbsent calls, with a code example.
This article explains why RequestContextHolder fails to retrieve the HttpServletRequest in a multithreaded Spring MVC environment, demonstrates the problem with a concrete example, analyzes the underlying thread‑local handling of request attributes, and clarifies the default non‑inheritable behavior that leads to null requests.
This article explains the principles and implementation of Java's Compare-and-Swap (CAS) and AbstractQueuedSynchronizer (AQS), illustrating how CAS enables lock‑free algorithms and how AQS underpins high‑level synchronization constructs like ReentrantLock and CountDownLatch, while also providing practical step‑by‑step examples.
The article examines performance bottlenecks in marketing systems when filtering blacklisted accounts, proposes multithreaded processing and bitmap-based set operations—including Java BitSet and RoaringBitmap—to dramatically reduce processing time from tens of minutes to milliseconds, and discusses implementation details, memory efficiency, and broader applications such as indexing and Redis.
This article explains the concepts of concurrency, parallelism, and serial execution, describes common multi‑core scheduling algorithms, and demonstrates Java's concurrent programming tools—including Future, Fork/Join, Stream API, and CompletableFuture—through clear code examples and practical guidelines.
This article explains why downloading large files blocks the UI in single‑threaded JavaScript, and demonstrates how to offload the heavy processing to Web Workers with practical code examples, allowing the page to remain responsive while the download proceeds.
This article outlines a comprehensive backend architecture for community platforms and billion‑level e‑commerce systems, covering microservice decomposition, DDD modeling, caching strategies, Redis clustering, message‑queue decoupling, database sharding, read‑write separation, distributed transaction approaches, multithreaded data migration, and massive counting techniques.
This article explains why multithreaded programs often feel like untamable beasts, introduces the core concept of thread safety, distinguishes private and shared resources, shows concrete C/C++ examples of safe and unsafe patterns, and outlines practical techniques such as thread‑local storage, read‑only globals, atomic operations and synchronization to write reliable concurrent code.
This article demystifies thread safety by comparing private and shared resources, defining when code is thread‑safe, illustrating common pitfalls with C/C++ examples, and presenting practical techniques such as using thread‑local storage, read‑only globals, atomic operations, and synchronization to write reliable multithreaded programs.
This guide explains the concepts of Hyper‑Threading, physical vs logical CPUs, how to query CPU information on Linux, and provides detailed instructions for using the taskset command and related programming APIs to set and retrieve CPU affinity for processes and threads.
Spring 6.2 introduces asynchronous bean initialization, a new addSingletonCallback mechanism, global transaction rollback settings, and injection performance optimizations, eliminating blocking during multi‑threaded event publishing and dramatically reducing startup time, as demonstrated with code examples and performance test results.
Semaphores, introduced by Dijkstra, are powerful synchronization primitives that manage concurrent thread access to shared resources through atomic P (wait) and V (signal) operations, offering flexibility and deadlock avoidance while posing challenges like complex state management and performance overhead.
The article enumerates eight common coding practices—such as fetching massive data at once, using Kafka auto‑acknowledgement, infinite loops, aggressive multithreaded imports, bulk file synchronization, deadlocks, poorly designed regexes, and heavy real‑time calculations—that can cause Java services to hit 100% CPU usage, explaining the underlying mechanisms like full GC, thread‑context switching, and NFA backtracking.
This tutorial walks through configuring Spring Batch on Spring Boot 2.7.16 to read data from one database, process it, and write to another, covering dependency setup, job and step beans, asynchronous execution, multithreading, job restart, and repeated launches with code examples.
This article explains the differences between threads and processes in Linux, introduces the concept of POSIX signals, describes how signals are delivered and handled in multithreaded programs, and provides a complete C example demonstrating proper signal handling across threads.
ThreadLocal in Java provides thread‑local variables by maintaining a per‑thread map, enabling data isolation, simplifying inter‑thread data transfer, and storing context information, while requiring careful handling to avoid memory leaks, thread‑pool contamination, and overuse.
This article explains how using a Java thread pool for multithreaded pagination can dramatically speed up large‑scale data queries, outlines thread‑pool concepts and benefits, details ThreadPoolExecutor parameters and work‑queue options, and reviews common rejection policies and built‑in pool factories.
This article explains the Java volatile keyword, covering its underlying principles, effects on visibility and instruction reordering, appropriate usage scenarios, limitations, and provides a practical code example demonstrating how volatile ensures thread visibility and prevents dead loops in multithreaded programs.
Learn the core principles of synchronization and mutual exclusion in multi‑process or multi‑threaded Linux environments, explore design concepts such as atomic operations and deadlock avoidance, and see complete POSIX‑thread code examples using semaphores, condition variables, mutexes and spinlocks.
Typical reasons for Java backend services hitting 100 % CPU include fetching massive data sets, misusing Kafka auto‑acknowledge, infinite loops or recursion, thread‑pool overload causing context‑switch thrashing, bulk file synchronization, lock‑order deadlocks, poorly designed regular expressions, and intensive real‑time calculations under high concurrency.
This article examines common reasons behind persistent 100% CPU usage in Java backend systems—ranging from excessive full GC and Kafka auto‑acknowledgment to dead loops, thread‑pool overload, massive file sync, deadlocks, inefficient regex and heavy real‑time calculations—offering practical diagnostics and solutions.
This article explores the fundamentals of multithreaded programming, comparing traditional lock-based synchronization with advanced lock-free techniques, and demonstrates how iLogtail implements thread models, memory barriers, atomic operations, spin locks, double-buffering, and deferred reclamation to achieve scalable, high-performance concurrency.
This article demonstrates how to boost the insertion speed of over two million records by configuring a Spring Boot ThreadPoolTaskExecutor, integrating it with MyBatis‑Plus and PostgreSQL, and measuring multi‑threaded versus single‑threaded performance to determine the optimal thread count.
