The article explains that when a Java thread encounters a heap OutOfMemoryError, the thread terminates but its allocated heap memory is reclaimed, allowing the remaining threads in the same process to continue operating, and demonstrates this with a multithreaded example.
This article experimentally examines how different sources of performance‑test error—fixed versus random request latency, thread‑count variations, and log‑printing overhead—affect QPS calculations, revealing that higher concurrency amplifies error while increased request repetitions and reduced logging improve measurement accuracy.
This article provides a comprehensive Python web‑scraping guide covering basic GET/POST requests with urllib2, proxy handling, cookie management, header manipulation to mimic browsers, gzip compression handling, regular‑expression and library parsing, simple captcha strategies, and a multithreaded thread‑pool example.
Redis, traditionally single‑threaded for network I/O and key‑value operations, introduced multithreading in version 6.0 to improve network I/O handling; this article explains the original single‑thread design, when multithreading is appropriate, its drawbacks, the role of I/O multiplexing, and why Redis still keeps most work single‑threaded.
This comprehensive guide introduces Java concurrency fundamentals, explains common tools and their underlying principles, discusses typical challenges such as thread safety, visibility, and ordering, and provides practical code examples and optimization techniques for building high‑performance multithreaded applications.
Redis, traditionally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions and improve performance, with detailed explanations of event handling, code implementations, limitations, and comparisons to Tair’s threading model.
This comprehensive guide explains why concurrency is essential for modern systems, introduces core metrics like response time and throughput, outlines the three pillars of thread safety, compares concurrency with parallelism, and provides practical solutions for deadlocks, thread creation, synchronization, and efficient thread‑pool usage in Java.
This article explains the fundamentals of Python threading, covering thread definitions, the threading module, two ways to create threads, daemon thread behavior, common thread‑safety issues, and how to use mutex locks to synchronize access to shared resources.
The article explains how Vivo’s platform implements a fault‑tolerant HTTP Range (breakpoint) download in Java—detecting server support, choosing single‑or multi‑threaded segmented downloads, using RandomAccessFile and retry logic, verifying integrity with ETag/MD5, and issuing alerts, while noting when the added complexity is justified.
This article explains how to eliminate the serial‑login bottleneck in multi‑user performance testing by using Java’s CyclicBarrier to synchronize user logins, then runs a two‑step insert‑update scenario with a custom FunTester class, complete with full code examples and result analysis.
This article explains Java concurrency by examining the memory model from fundamental concepts through sequential consistency, the happens‑before relationship, and the subtle notion of causality, helping readers grasp how Java guarantees correct multithreaded behavior while allowing performance optimizations.
This article explains Python’s built‑in concurrent.futures module, detailing how ThreadPoolExecutor and ProcessPoolExecutor work, when to use each, how to submit tasks, shut down pools, handle callbacks, and adapt the examples for I/O‑bound and CPU‑bound workloads.
This article provides a comprehensive, systematic guide to Java concurrency, covering fundamental concepts, key keywords such as volatile, final, and synchronized, and an in‑depth exploration of the J.U.C framework including locks, atomic classes, concurrent collections, thread pools, and utility classes.
This article explains the various usages of Java's synchronized keyword, including class locks, object locks, static and instance methods, code blocks, and important considerations such as non‑interruptibility, reentrancy, lack of timeout, and best‑practice performance tips, illustrated with multiple demo programs.
This guide demonstrates how to use TestNG for exception validation, method dependencies, XML and DataProvider parameterization, multithreaded execution via annotations and XML suites, and timeout enforcement, providing complete Java code examples for each feature.
The article explains how multithreading can improve web request throughput and scalability, illustrates performance gains with example I/O tasks, discusses pitfalls of shared HashMap in servlets, and presents thread‑safe caching solutions using ConcurrentHashMap and FutureTask to reduce latency and avoid concurrency bugs.
This article explains the fundamental concepts of processes and threads in operating systems, compares their characteristics, advantages, and disadvantages, and provides practical guidelines on when to use processes, threads, or a combination of both for concurrent execution.
This article demonstrates how to build a Java-based web crawler that fetches image URLs from Sogou Image Search, parses the JSON response, and downloads thousands of pictures to a local directory using multithreaded processing and custom HTTP utilities.
This article presents a practical demo for multi‑chain performance testing with FunTester, describing the overall workflow, custom multithreaded implementation, Java code example, and sample console output to illustrate how to execute and analyze load tests across multiple request paths.
This article provides a comprehensive guide to Python web scraping, covering basic GET/POST requests, proxy usage, cookie management, browser header spoofing, gzip compression handling, and multithreaded crawling to improve efficiency and avoid common obstacles.
This article walks through building a custom thread pool executor in Java, starting with a simple thread creation example, evolving through multiple design iterations, and culminating in a full-featured implementation that supports core and maximum pool sizes, task queues, thread factories, and rejection policies.
This article explains the Java synchronized keyword, its three purposes, usage forms for instance methods, static methods, and code blocks, and delves into the underlying monitor mechanism, object header structure, lock states, lock escalation, and related JVM optimizations with illustrative code examples.
This article explains how to use Java's CyclicBarrier and related concurrency utilities to parallelize user login preparation for load testing, reducing setup time and synchronizing multi‑stage performance tests with concrete code examples and sample console output.
Optimizing app launch on iOS and Android—through deep‑link handling, H5 splash strategies, On‑Demand Resources, custom WKWebView schemes, reduced download size, static and runtime .so loading flags, thread‑pool tuning, method swizzling, actor‑based concurrency, and using Instruments, MetricKit and Android Profiler—prevents user abandonment and boosts conversion.
This article explains CPU architecture, cache hierarchy, the concept of cache lines, how false sharing degrades performance, mitigation techniques like cache‑line alignment, and the Linux scheduler's task prioritisation, virtual runtime, and run‑queue mechanisms for fair and real‑time execution.
This article explains the concept of thread pools, compares seven creation methods—including FixedThreadPool, CachedThreadPool, and ThreadPoolExecutor—covers their parameters, execution flow, and rejection policies, and offers guidance on selecting the most appropriate pool for Java applications.
This article describes how to implement a multi‑interface performance test for the collect and uncollect operations of a teacher’s resource list, using Groovy scripts, a custom FunTester framework, multithreaded request generation, request‑id tracking, and response recording to produce QPS and RT metrics.
This comprehensive guide compiles 108 common Java multithreading interview questions, covering the purpose of concurrency, thread creation methods, lifecycle nuances, synchronization utilities, memory visibility, thread safety levels, debugging techniques, executor frameworks, concurrent collections, atomic operations, lock implementations, and best‑practice recommendations.
This article explains how to build a real‑time network chatroom in Java using TCP sockets, multithreading, and a ConcurrentHashMap to manage user connections, detailing command handling for listing users, group chat, private messages, exiting, and server shutdown, with full source code examples.
This article explains the evolution from single‑core to multi‑core computing, introduces memory models as a protocol for ordering memory operations, details the Java memory model’s definition, its impact on Java and other languages, and provides practical examples and insights into synchronization, volatile, and happens‑before rules.
The article uses a casual conversation between two backend engineers to introduce multithreading concepts, explain shared vs. private resources, define thread‑safe and reentrant functions, illustrate common pitfalls with code examples, and provide practical guidelines for writing correct concurrent C++ services.
This article explains why multithreading improves program performance, distinguishes latency reduction from throughput increase, and provides practical formulas to determine the ideal number of threads for both I/O‑bound and CPU‑bound workloads, helping you fully utilize hardware resources.
This session reviews PThread fundamentals and advanced techniques in C, covering thread creation, termination, attributes, mutexes, reader‑writer locks, condition variables, semaphores, barrier synchronization, and thread‑specific data, with code examples and a concluding homework assignment.
This article explains why multithreaded inserts into a single MySQL table can be faster than single-threaded inserts, analyzes the time distribution of insertion operations, and presents techniques such as prepared statements, multi-value inserts, batch execution, and transaction batching to significantly improve insert throughput.
This article presents various Java solutions for common interview multithreading problems that require sequential printing, demonstrating implementations using Lock, wait/notify, Condition, Semaphore, and LockSupport, along with detailed code examples and explanations of thread communication mechanisms.
FUSE implements a user‑space file‑system framework where a kernel module creates the /dev/fuse device and forwards VFS requests into kernel queues, while a multi‑threaded daemon reads these requests, optionally uses splice for zero‑copy, processes them, and writes replies back, enabling simple file‑system development without kernel recompilation.
This article explores how to apply Java generics in a multithreaded task framework, demonstrates refactoring a ThreadBase class, provides concrete code examples with RequestThreadTimes, and discusses the challenges and solutions for generic type constraints in inheritance hierarchies.
This article explains seven common Java synchronized usage scenarios, analyzes whether each case is thread‑safe, provides detailed code examples and execution results, and offers practical guidance for interview preparation and correct multithreading design.
This tutorial walks you through using various Python modules—including requests, wget, urllib, urllib3, boto3, and asyncio—to download regular files, web pages, Amazon S3 objects, handle redirects, large files, parallel downloads, proxies, and progress bars, all with clear code examples.
This guide explains how to use conditional breakpoints, drop‑frame, thread‑specific suspension, remote debugging configuration, and on‑the‑fly expression evaluation in Java IDEs, providing step‑by‑step instructions and visual examples to help developers debug complex applications more effectively.
This article compiles a series of common Java interview questions covering StringBuilder versus String concatenation, null‑check pitfalls, Integer caching behavior, parameter passing, array‑to‑list conversion limits, directory creation methods, floating‑point precision, multithreading techniques, loop edge cases, and the guaranteed execution of finally blocks.
This article introduces the fundamentals of Java multithreading, explaining why concurrency is needed, the differences between programs, processes and threads, four ways to create threads, and common pitfalls such as thread safety and deadlocks, all with clear code examples.
This article explains Java thread pools, covering their purpose, advantages, core components, constructor parameters, built‑in pool types such as Cached, Fixed and Single thread pools, and the available rejection policies, providing code examples and practical guidance for efficient multithreaded programming.
This article explains Java's thread lifecycle, detailing its six states—New, Runnable, Blocked, Waiting, Timed_waiting, and Terminated—and describes eleven commonly used thread APIs such as join(), wait(), notify(), yield(), sleep(), currentThread(), getName(), getId(), getPriority(), setPriority() and stop().
This article provides a detailed guide to various Java lock types—including optimistic, pessimistic, spin, reentrant, read‑write, fair, unfair, shared, exclusive, heavyweight, lightweight, biased, segment, mutex, synchronization, deadlock, lock coarsening, and lock elimination—explaining their principles, typical usages, advantages, disadvantages, and related JVM optimizations.
This article explains Java's Compare-And-Swap (CAS) mechanism, illustrates its usage with AtomicInteger code examples, walks through step‑by‑step debugging of CAS operations, and discusses its advantages, limitations such as the ABA problem and spin‑wait overhead.
This article explains the fundamentals of Java threads, contrasting them with processes, demonstrates thread creation via extending Thread and implementing Runnable, discusses the benefits of multithreading, covers thread priority settings, and details the lifecycle states and transitions with practical code examples.
Faced with tens of thousands of dirty records and no bulk‑delete API, the author iteratively optimized a deletion script—starting with simple serial requests, then adding asynchronous HTTP calls, and finally employing multithreading—to achieve rapid, reliable removal of hundreds of entries per second.
This article explores Java’s synchronized keyword in depth, covering its purpose, usage with object and class locks, seven multithreading scenarios, core principles like reentrancy and visibility, performance drawbacks, and best practices for choosing between synchronized and explicit Lock implementations.
Understanding Java's thread lifecycle—from creation (NEW) through runnable execution, waiting states, blocking, and termination—is essential for multithreaded development, and this guide breaks down each state, transitions, and relevant code examples to help you master concurrency concepts.
This article details Youku's membership marketing system architecture, covering complex marketing scenarios, high‑availability and low‑latency requirements, rule‑based QL engine, unified marketing framework, multi‑cache storage, multithreaded matching, asynchronous reward distribution, and distributed transaction mechanisms.
This article explains how Java’s Phaser class extends the capabilities of CountDownLatch and CyclicBarrier, offering dynamic phase management for multistage tasks, details its constructors and key methods, compares usage scenarios, and provides a complete code demo illustrating practical implementation.
This article explains Java’s CountDownLatch class, covering its package location, constructor, essential await and countDown methods, and demonstrates practical integration within a multithreaded performance testing framework, including sample code for task execution, thread management, and cleanup.
This article demonstrates how to build a Python TCP port scanner using raw sockets, adds service fingerprinting by sending probes, speeds up scans with multithreading, and shows an alternative approach using the nmap library, complete with example code and sample output.
This article explains various Java thread‑communication mechanisms—including thread.join(), object.wait()/notify(), CountDownLatch, CyclicBarrier, Callable, and FutureTask—through clear examples, code snippets, and execution results, helping developers coordinate thread execution and retrieve results from worker threads.
This article explains how the Liulishuo team leveraged the Cocos game engine to render video directly, managed OpenGL contexts across multiple threads, and built a reusable audio‑video processing pipeline for Android, detailing challenges, design decisions, and implementation solutions.
This article explains the difference between class locks (static synchronized) and object locks (instance synchronized) in Java, demonstrates their behavior with multithreaded examples, and shows how lock scope affects execution order and synchronization.
This article explains the concept of reentrant locks in Java, compares ReentrantLock with the synchronized keyword, and provides a detailed walkthrough of the internal source code for lock acquisition, fairness policies, and lock release using AQS, complete with code examples.
The article shares practical experiences on running test cases concurrently using Java multithreading and a custom thread pool, and outlines MySQL database naming, null handling, and schema design guidelines, including full code examples for the case runner and thread pool implementation.
This article explains why thread pools are essential for Java applications, details the seven key parameters of ThreadPoolExecutor, describes the possible thread‑pool states, and walks through the core methods such as execute, addWorker, runWorker and getTask with code examples.
This article explains the various types of locks provided by Java, compares optimistic and pessimistic locking, introduces spin locks and adaptive spin locks, details lock states such as biased, lightweight, and heavyweight, and examines fair versus non‑fair, reentrant versus non‑reentrant, and exclusive versus shared locks with source code references.
The article explains why Java concurrency is fraught with hidden traps, outlines four key misconceptions, and offers practical guidance on safely using threads, understanding memory models, and recognizing the limits of testing and libraries.
This article provides a comprehensive tutorial on Java's volatile keyword, covering its role in the Java Memory Model, the three concurrency fundamentals of atomicity, visibility, and ordering, and detailed explanations of volatile's visibility, ordering guarantees, implementation mechanisms, and a source code example.
This article provides a comprehensive guide to Java's thread lifecycle, detailing each of the six thread states, their meanings, how they are triggered, and practical code examples that demonstrate state transitions and logging output.
This article explains why a while loop is required rather than an if statement when using wait() inside synchronized blocks, demonstrates the race condition with a bounded buffer example, shows the correct fix, discusses notifyAll versus notify, and illustrates how improper use can lead to deadlocks in Java multithreading.
This article explains how to design and implement a multithreaded framework for executing test cases concurrently in Java, covering thread‑pool creation, a runnable test‑case class, collection execution logic, and parameter handling with user credentials and random data generation.
This article provides a comprehensive guide to Java's synchronized keyword, covering its purpose, object and class lock usage, seven multithreading scenarios, reentrancy and non‑interruptibility properties, underlying lock and visibility mechanisms, performance drawbacks, and common questions with detailed code examples.
This article explains several classic Java concurrency patterns—including various Singleton implementations, the Future and FutureTask mechanisms, producer‑consumer queues, Master‑Worker coordination, and the ForkJoin framework—providing code examples and practical usage notes for each.
This article explains several techniques to boost RabbitMQ consumption speed, including adding more consumers, tuning the prefetch count, employing multithreaded processing, and using batch acknowledgments, while discussing related challenges such as backend capacity, concurrency conflicts, and message ordering.
This tutorial demonstrates how to use Python's requests, threading, and queue modules to build a multithreaded crawler that extracts game names, download links, and execution time from the Xiaomi App Store, complete with code examples and performance tips.
This article explains Java’s thread interruption mechanism, detailing the purpose and differences of interrupt(), isInterrupted() and interrupted(), how interruption flags work, when InterruptedException is thrown, proper handling practices, common usage scenarios, and examples from JDK classes such as ThreadPoolExecutor and FutureTask.
This article thoroughly examines Java's ConcurrentHashMap, covering its evolution from JDK 1.7 segmented locks to JDK 1.8's CAS‑based design, detailing key internal fields, the thread‑safe put and remove operations, and the complex resizing and transfer mechanisms that enable high‑concurrency performance.
This article explains the Java synchronized keyword, detailing its four core properties—atomicity, visibility, ordering, and reentrancy—while illustrating its bytecode behavior, lock types, upgrade mechanisms, and JVM optimizations such as biased, lightweight, and heavyweight locks, lock elimination, and lock coarsening.
This article explains Python's threading module, demonstrating how to import it, create and manage single and multiple threads, use thread locks (Lock and RLock), condition variables, semaphores, events, thread‑local storage, and timers, providing complete code examples for each concept.
This guide explains Java's synchronized keyword, detailing how object‑level and class‑level locks work, provides code examples for each, and lists essential best‑practice tips and common pitfalls to avoid when writing thread‑safe Java code.
Redis 6.0.0 GA, the biggest release to date, adds a redesigned client cache, ACL improvements, faster RDB loading, a new STRALGO command, and optional multithreaded I/O that can double network performance, while urging careful testing before production use.
This article provides a comprehensive walkthrough of Java's AbstractQueuedSynchronizer (AQS), its state and FIFO wait queue, the inner workings of ReentrantLock with both non‑fair and fair lock strategies, and the detailed mechanics of Condition objects with code examples and diagrams.
This article explains the core components and operation of a CPU, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multi‑core and hyper‑threading concepts, and the hierarchy of caches from registers to L3, providing a comprehensive fundamentals overview.
This article explains how to build two Java load‑testing modes—quantitative and timed—by extending thread‑limit classes, managing GCThread lifecycle, sending HTTP requests with FanLibrary, and correctly cloning request objects to avoid bugs during multithreaded performance testing.
This article explains two load‑testing strategies—fixed‑iteration (quantitative) and fixed‑duration (timed)—and provides complete Java implementations, usage guidance, and a Gitee repository link for a multithreaded performance testing framework.
This article explains how to design a Java performance testing framework by defining an abstract multithreaded base class for common behaviors, implementing two virtual classes for different load‑testing modes, and creating an execution class that orchestrates thread pools, collects metrics, and generates visual reports, with full source code examples and a Gitee repository link.
This article explains why multithreading remains essential, distinguishes CPU‑bound and I/O‑bound scenarios, provides formulas for calculating the optimal number of threads, discusses interview questions, and highlights practical considerations such as thread pools and synchronization.
This article explains why Java 8's ConcurrentHashMap.get() operation is lock‑free, describing the underlying data‑structure changes from JDK 1.7 to 1.8, the role of volatile‑marked Node fields and array, and how visibility and cache‑coherence guarantee thread‑safe reads.
This article walks through the progression of Java server‑side I/O—from classic blocking BIO, through multithreaded and thread‑pool BIO variants, to non‑blocking NIO and Reactor‑based scalable designs—explaining core concepts, code examples, and performance trade‑offs.
This article explores Kotlin/Native's asynchronous concurrency model, detailing the three native approaches—OS‑level threads, Kotlin/Native coroutines, and Workers with object subgraphs—while also examining the preview multithreaded coroutine support, transfer modes, annotations, and practical code examples.
This article details recent updates to a performance testing framework, including moving the mark feature into ThreadBase, changing method signatures, introducing two virtual thread limit classes for count‑based and time‑based execution, optimizing after() handling, and abandoning deep‑copy cloning for thread objects.
This article explains why thread safety is essential in concurrent Java programs, introduces the lock concept, and provides detailed examples of using the synchronized keyword to protect code blocks, instance methods, static methods, and entire classes, including common pitfalls and inheritance rules.
This article explains how to generate, propagate, and log unique request IDs across multithreaded HTTP calls in a Java performance‑testing framework, providing a MarkRequest interface, a RequestThreadTimes implementation, and a runnable demo that captures request‑ID timestamps for analysis.
This article provides a comprehensive overview of Java concurrency concepts, covering thread‑safety issues, variable visibility, atomic operations, the use of synchronized, volatile, ReentrantLock, ReadWriteLock, CountDownLatch, and other AQS‑based synchronizers, with code examples illustrating each mechanism.
This article explains how a CPU executes programs through the fetch‑decode‑execute cycle, describes instruction sets, registers, pipelines, superscalar and multithreaded designs, and details the cache hierarchy from registers to L3, providing a comprehensive overview of modern processor fundamentals.
This article explains multithreading fundamentals, covering thread concepts, lock mechanisms for database access, deadlock causes and solutions, recursive locks (RLock), data race issues, and daemon thread behavior. It also discusses connection pooling, timeout strategies to avoid deadlock, and practical code examples in Python.
This article provides a comprehensive guide to common Java multithreading interview questions, covering thread ordering with join, lock vs synchronized, read‑write locks, wait vs sleep, blocking queues, producer‑consumer patterns, deadlock detection, thread dumps, thread states, and immutable objects, all illustrated with runnable code samples.
This article explains how a CPU executes programs through the fetch‑decode‑execute cycle, describes instruction sets, registers, pipelines, superscalar and multithreaded designs, and details the hierarchy of caches from registers up to L3, providing a comprehensive overview of modern processor fundamentals.
This article explains how to build a multi‑threaded Kafka consumer and producer in Java, covering partition concepts, consumer group offsets, thread‑pool configuration, and code examples that demonstrate proper use of Kafka streams, partition keys, and batch message sending for improved throughput.
A comprehensive guide that explains Python concurrency concepts—including processes, threads, synchronization primitives, thread pools, asyncio, greenlet, and gevent—while showing how to choose the right model for CPU‑bound or I/O‑bound tasks.
This article explains how to extend an existing Java performance‑testing framework by adding a fixed‑time mode alongside the traditional fixed‑count mode, detailing the design of ThreadBase, ThreadLimitTimes, ThreadLimitTime classes, demo implementations for HTTP requests, and key design considerations for low‑overhead timing and early termination.
This article uses a vivid fruit‑store analogy to explain Java multithreading concepts such as locks, synchronized blocks, wait/notify, thread states, time‑slicing, and volatile variables, helping readers grasp core concurrency mechanisms in an engaging narrative.
This article explains why HashMap is unsafe in multithreaded environments, how ConcurrentHashMap uses segmented locks and immutable entries to achieve high concurrency, and details its internal data structures, core operations, and performance considerations with illustrative Java code examples.
The article uses a vivid fruit‑store story to illustrate core Java concurrency concepts such as threads, lock objects, critical sections, thread states, synchronization queues, wait/notify mechanisms, and volatile variables, helping readers grasp multithreading fundamentals through relatable scenarios.
This guide explains essential Java debugging techniques—including conditional breakpoints, dropping to a previous stack frame, handling multithreaded breakpoints, remote debugging setup, and evaluating or modifying expressions on the fly—providing clear steps and visual examples to help developers debug more efficiently.
