This comprehensive guide traces the full execution path of a Linux program from user-space glibc calls through system calls into the kernel, covering process management, memory allocation, threading, I/O buffering, dynamic linking, and practical debugging techniques.
This article details how Douyin engineers tackled Android’s limited heap, file‑descriptor, and thread constraints on older phones by expanding ART malloc and region spaces, enlarging FD/FD_SET limits, and implementing a transparent M:N user‑level threading model, achieving significant stability and performance gains.
This article examines Python's three concurrency models—threading, multiprocessing, and asyncio coroutines—detailing their underlying mechanisms, performance traits, suitable use‑cases, and the impact of the Global Interpreter Lock, followed by a hybrid web‑server implementation example.
Exploring the historical shift from memory‑constrained SMP systems and POSIX threads to today’s powerful hardware, this article argues that the ‘share‑nothing’ concurrency principle—embodied in Go’s CSP model and PHP’s parallel extension—should replace legacy lock‑based paradigms as the default approach.
This article explains the differences between concurrency and parallelism, the impact of Python's Global Interpreter Lock, and provides a detailed comparison of threading, multiprocessing, and asyncio with code examples, performance tests, decision flowcharts, mixed‑usage patterns, common pitfalls, and best‑practice recommendations for choosing the right approach.
This article explains the difference between concurrency and parallelism, the impact of Python's GIL, and provides a detailed comparison of threading, multiprocessing, and asyncio with code examples, performance tests, decision flowcharts, best‑practice tips, and a summary table to help you choose the right concurrency model for your tasks.
AbstractQueuedSynchronizer (AQS) is the core framework for building Java locks and synchronizers, providing state management, FIFO queuing, and blocking/unblocking mechanisms; this article explains its components, design patterns, thread safety operations, and real-world implementations such as ReentrantLock and Semaphore, with code examples.
Learn nine distinct Python approaches for copying files—including shutil functions, os commands, threading, and subprocess methods—while understanding their performance implications, error handling, platform compatibility, and when to choose each technique for optimal I/O efficiency.
This article explains Python's multithreading concepts, covering thread creation via subclassing Thread or using target functions, synchronization mechanisms like Lock, RLock, and Condition, and discusses the impact of the Global Interpreter Lock, helping readers apply threading effectively for I/O‑bound tasks.
This article explains the concepts of processes and threads, describes Python's Global Interpreter Lock (GIL) and its impact on concurrency, compares the low‑level _thread module with the higher‑level threading module, and provides example code illustrating thread creation, synchronization with locks, and common pitfalls.
This article explains Java virtual threads introduced by Project Loom, compares them with platform threads in terms of memory usage and creation time, provides code examples for creating and managing virtual threads, and outlines practical guidelines and use‑cases for high‑concurrency backend applications.
Redis evolved rapidly, with versions up to 5.x handling all core CRUD commands on a single worker thread, while Redis 6 introduced multi‑threaded network I/O to leverage multi‑core CPUs, yet still processes core business commands single‑threadedly for performance and simplicity, as explained with diagrams.
The article explains why using Thread.sleep in a loop causes busy‑waiting and performance problems, and demonstrates several Java scheduling alternatives—including Timer/TimerTask, ScheduledExecutorService, wait/notify, and CompletableFuture—to efficiently check a flag at fixed intervals.
The article explains how multi‑core CPUs use time slices and hyper‑threading to run multiple threads, describes the mechanics and costs of thread context switching, compares preemptive and cooperative scheduling, and offers practical tips for reducing switching overhead and optimizing thread counts.
This article provides a comprehensive overview of essential Python concepts—including decorators, list comprehensions, generators, exception handling, modules, threading, shallow and deep copying, garbage collection, variable arguments, closures, method types, process‑thread differences, relational vs NoSQL databases, array vs linked‑list structures, and the distinction between HTTP and Web Service API testing—illustrated with clear explanations and runnable code examples.
This article explains Java's AbstractQueuedSynchronizer (AQS) framework, detailing its FIFO queue, state handling, entry‑wait queue, exclusive and shared lock acquisition, condition‑variable queues, and how core concurrency utilities like ReentrantLock, ReadWriteLock, CountDownLatch, Semaphore, and ThreadPoolExecutor are built on it.
This article explains why traditional Python multithreading tutorials are often overly complex, introduces the concise map‑based approach using multiprocessing and multiprocessing.dummy ThreadPool, demonstrates performance gains with real‑world examples, and provides ready‑to‑run code snippets for efficient parallel execution.
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 examines why Kotlin coroutine concepts are hard to explain, identifies common shortcomings in existing tutorials, and proposes a step‑by‑step approach that starts from basic thread concepts, uses incremental examples, and introduces task‑flow techniques to clarify coroutine behavior.
This article explains how Redis operates primarily with a single‑threaded model for memory and network operations, why this design is efficient, and how recent versions introduce multi‑threaded components for network I/O, persistence, and asynchronous deletion while preserving thread safety.
This guide compares Python's synchronous requests library with the asynchronous grequests wrapper, showing when to choose each approach and providing clear code examples for single-threaded, multi-threaded, timeout‑controlled, and exception‑handled HTTP requests.
The article explains Android jank, defines Google and PerfDog metrics, identifies direct and indirect causes, recommends profiling tools such as Systrace, Perfetto and APM, and details a Wesing case study where breaking tasks, lazy loading, view‑hierarchy reduction and thread off‑loading cut PerfDog jank by roughly half, concluding with a checklist for systematic detection and mitigation.
This article explains Python's multithreading model, covering thread creation, synchronization, data sharing, and provides practical code examples for sending concurrent API requests, downloading files, running test cases, reading files, and inserting records into a SQLite database.
This article explains Python's thread‑synchronization primitives—including locks, RLocks, conditions, events, semaphores, read‑write locks, queues, thread pools, the GIL, and high‑level concurrency libraries—while providing ten ready‑to‑run code examples for each mechanism.
This article reviews a series of typical programming blunders—such as incorrect local file includes, misuse of obscure characters, over‑reliance on long if‑else chains, meaningless variable names, hard‑coded outputs, thread‑sleep misuse, and missing return statements—highlighting the practical lessons each mistake provides for developers.
This tutorial explains process and thread fundamentals, compares single‑threaded and multithreaded Python crawlers, provides complete code examples for both approaches, and demonstrates how converting a single‑threaded scraper to multithreading can significantly reduce execution time when handling large data volumes.
Learn how converting single‑threaded Python crawlers into multithreaded ones can dramatically reduce data‑fetching time, covering process vs thread concepts, practical threading code examples, performance comparisons, and a step‑by‑step guide to building a multithreaded image scraper.
This article explains why traditional Unix fork/exec models are costly, introduces POSIX threads (Pthreads) as a lightweight alternative, and provides detailed guidance on thread data structures, creation, termination, synchronization primitives, and attribute configuration with practical code examples for Linux developers.
This article explains the limitations of the traditional Unix fork model, introduces POSIX threads as lightweight processes, details their data structures, core functions, creation, termination, synchronization primitives, attributes, and provides extensive C code examples for practical multithreaded programming on Linux.
This article provides a comprehensive guide on building a network port scanner using Python, covering implementation principles, code examples, and practical usage instructions.
Baidu dramatically accelerated its Android app’s launch by dissecting the cold‑start sequence, applying full‑path analysis, leveraging tracing tools, introducing a priority‑aware task‑scheduling framework, replacing SharedPreferences with the binary UniKV store, eliminating lock contention, and tightening thread, I/O, and library loading, which together cut ANR rates and boosted user retention.
This article explains how to create a Python‑based network port scanner that probes a target host, uses sockets and multithreading to detect open TCP ports, and provides clear usage instructions, sample code, and optional enhancements for faster or more comprehensive scanning.
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 explains Java's AbstractQueuedSynchronizer (AQS) core architecture, including its state variable, CLH queue, condition queue, template methods, and the detailed implementations of acquire, release, and node management that enable building custom locks and synchronizers.
The article explains the core performance metrics QPS, TPS, response time (RT), concurrency, and throughput, provides formulas to relate them, demonstrates practical calculations for capacity planning, and discusses how to determine the optimal number of threads for a backend system.
This article explains a common Python multiprocessing pitfall, showing how using target=function_name without parentheses correctly launches a new process, and illustrates the difference between passing a function object versus calling the function, accompanied by screenshots of the discussion, runtime output, and a concise solution.
This article explains why simple serial file reads are slow, compares multithreaded and event‑loop based approaches, introduces the Reactor pattern and callbacks, and finally shows how coroutines provide a synchronous‑style solution for efficient, non‑blocking I/O processing.
This article translates and expands on a HikariCP wiki post, explaining why a small database connection pool often yields better performance than a large one, presenting benchmark data, a practical sizing formula, and guidance for tuning pools in various environments.
The article explains how modern multi‑core CPUs use time slices, hyper‑threading, and various thread scheduling strategies, describes the overhead of context switches, and offers practical optimization techniques to balance thread count and improve concurrency performance.
Thread.Sleep pauses a thread for a specified duration, signaling the OS to exclude it from CPU competition, and Thread.Sleep(0) forces an immediate rescheduling, which can improve UI responsiveness by yielding control to other threads; the article explains these behaviors using time‑slice and preemptive scheduling analogies.
This article shares a comprehensive Java concurrency interview guide covering thread states, communication methods, and key concepts, and explains how to obtain the full PDF resource via a WeChat public account.
This article provides a comprehensive guide to Python concurrency, covering the fundamental differences between threads and processes, the impact of the Global Interpreter Lock, and detailed usage of the multiprocessing module with its various components and synchronization primitives.
This article explains the fundamental differences between threads and processes, the role of Python's Global Interpreter Lock (GIL), and how to use the multiprocessing package—including Process, Pool, Queue, Pipe, and synchronization primitives—as well as an overview of concurrent.futures for high‑level concurrent programming in Python.
This article explains why Python threads cannot be killed directly, demonstrates the default waiting behavior on program exit, and provides two practical techniques—using daemon threads and threading.Event objects—to allow background threads to terminate cleanly when a user interrupts the process.
This article delves into Python's threading module, explaining thread safety, the role of various lock types—including Lock, RLock, Condition, Event, and Semaphore—along with their methods, usage patterns, common pitfalls like deadlocks, and practical code examples to illustrate proper synchronization techniques.
This article investigates a deadlock between the Main Thread and the JavaScriptCore Heap Collector Thread on iOS 13, explains the underlying mutex and RunLoop interactions, reproduces the issue with CFTimer‑based timers, and proposes an AutoReleasePool‑wrapped solution along with best‑practice recommendations for JavaScriptCore usage.
This article explains why thread start order differs from execution order in Java and demonstrates four techniques—Thread.join, a single‑thread executor, a volatile flag, and ReentrantLock with conditions—to guarantee that multiple threads run and print their results in a deterministic sequence.
This article provides a comprehensive guide to Python threading, covering core concepts such as thread creation, synchronization primitives like locks, RLocks, conditions, semaphores, events, local storage, and timers, complete with practical code examples and explanations of their usage and pitfalls.
This article provides a comprehensive guide to Python threading, covering core concepts such as threads, locks, RLock, conditions, semaphores, events, local storage, and timers, along with practical code examples for creating, managing, and synchronizing threads to improve concurrent program performance.
This article reviews the evolution of Node.js N-API, its ABI‑stable add‑on API, new multithreading and context support features, helper functions, build tooling options, and provides practical guidance for getting started and contributing to the ecosystem.
This article presents a systematic analysis of how thread numbers, request counts, response times, and response‑time variance affect performance‑testing error rates, using a Java demo that simulates single‑API calls and reports detailed JSON metrics for each configuration.
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.
This article explains how Redis evolves from a single‑threaded event‑driven cache to using Lazy Free for asynchronous key deletion and multi‑threaded I/O for improved performance, detailing the underlying mechanisms, code implementations, limitations, and comparisons with Tair's threading model.
This article uses a single illustrative diagram to explain how .NET's async/await works, detailing thread release during I/O, overlapped I/O via IOCP on Windows, continuation scheduling, and differences on Linux with epoll, highlighting scalability and thread reuse benefits.
This article explains how Netty creates and uses the main thread, boss thread, and worker threads through NioEventLoopGroup and selectors, detailing the initialization of ServerSocketChannel, event registration, and the transition from OP_ACCEPT registration to active listening.
This tutorial walks through the complete development of a Java Swing runner game called RunDay, covering requirement documentation, MVC design, login, start screen, loading screen with threading, main gameplay including background scrolling, player animation, multiple obstacle types, collision detection, pause/continue logic, and the final end‑screen UI, all illustrated with full source code snippets.
This article provides a comprehensive source‑code walkthrough of Kotlin coroutines, explaining how launch creates a coroutine, how the compiler transforms suspend functions into state‑machine classes, and detailing the mechanisms of suspension and resumption through Continuation, Dispatchers, and the coroutine scheduler.
This article explains how to design a network framework from the ground up, explores the three‑layer understanding of frameworks, details the core components, thread scheduling, request/response processing chains, and then deep‑dives into OkHttp and Retrofit implementations, their limitations, and extensibility techniques.
This article explains how to enforce a specific execution order among three Java threads—first thread 1, then thread 2, and finally thread 3—using four techniques: the join method, CountDownLatch, a single‑thread executor, and CompletableFuture, each illustrated with complete code examples.
This article explains the purpose of Thread.Sleep, clarifies common misconceptions about its timing behavior, compares Unix time‑slice and Windows preemptive scheduling using a cake‑eating analogy, and shows why Thread.Sleep(0) can trigger an immediate CPU‑competition reschedule to improve responsiveness.
Thread.Sleep pauses a thread for a specified time, influencing CPU competition; understanding its behavior—including the surprising effects of Sleep(0) and how operating systems schedule threads via time‑slicing or preemptive strategies—reveals why Sleep can affect responsiveness and why it’s used in tight loops.
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 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 article explains how thread context switching and concurrency affect Java program performance, demonstrates the impact with code examples and benchmarks, and provides practical solutions for thread safety, visibility, deadlock avoidance, and resource optimization.
Learn step-by-step how to install pyserial, read and write serial data in Python, and use pyqtgraph with threading to create a real-time waveform visualization, including code examples and tips for handling baud rates, timeouts, and data queues.
This article explains why Python's OS‑level threads can be slower for CPU‑bound tasks due to the Global Interpreter Lock, describes race conditions caused by reference counting, and shows how using threading locks (including context‑manager syntax) ensures correct concurrent execution.
The article recounts the author’s journey of building a mini‑program engine, detailing the challenges of using Vue in a sandboxed environment, the trade‑offs between single‑thread and dual‑thread models, and the architectural decisions made to balance security, performance, and native capabilities.
This article chronicles the architectural evolution of a web‑based mini‑program engine, detailing the challenges of sandboxing Vue, restricting unsafe tags, handling performance and native capability limits, and ultimately adopting a dual‑thread model to achieve security and control while preserving developer experience.
This article explores Python's threading model, explains why threads may not exit automatically, demonstrates how the setDaemon() method turns threads into daemon threads to allow graceful shutdown, and delves into the interpreter's shutdown process and underlying C implementation details.
This article presents a Groovy‑driven, modular API testing framework that automates login, token handling, and password‑change requests using multithreaded execution, and includes full source code for the test driver, UserCenter, and OkayBase classes.
This article provides a comprehensive overview of core Java concepts for interview preparation, covering object‑oriented programming fundamentals, differences between OOP and procedural programming, detailed explanations of JVM, JDK, JRE, comparisons with C++, string handling, constructors, inheritance, polymorphism, threading, garbage collection, and related code examples.
This article walks through the complete journey of a single Java statement—from high‑level source code, through compilation to bytecode, JVM interpretation and JIT compilation, down to CPU instruction fetching, decoding, execution, caching, memory hierarchy, threading, interrupts, and the underlying Linux process model.
This article explains the complete execution path of a single Java line—from the Von Neumann CPU components, instruction fetch‑decode‑execute pipeline, Java bytecode generation, JVM class loading and interpretation, memory layout and caching, to Linux process memory management, thread scheduling, synchronization mechanisms and timer implementation—providing a deep technical foundation for Java performance tuning.
This article explains how to create and start threads in C#, covering ThreadStart delegates, lambda expressions, passing parameters, naming threads, foreground/background distinctions, thread priority, and exception handling, with clear code examples and best‑practice recommendations.
This article explains the differences between processes and threads, the role of Python's Global Interpreter Lock, how to create and manage threads with the thread and threading modules, and how to use synchronization primitives and the Queue module for producer‑consumer patterns.
This article explains Python's threading support, covering the thread and threading modules, ways to create threads, join and daemon settings, synchronization primitives, queue-based communication, thread pool usage and custom implementation, and the impact of the Global Interpreter Lock.
This article compiles the most frequently asked Java multithreading and concurrency interview questions—covering thread ordering, locks, wait/sleep differences, blocking queues, producer‑consumer patterns, deadlocks, atomic operations, volatile, race conditions, thread dumps, and more—providing concise explanations and code hints to help candidates ace banking and high‑frequency trading developer interviews.
This article explains how to create a Python script that monitors multiple websites, detects downtime, sends email alerts, and uses threading for concurrent checks, illustrating the implementation of site_up and site_down functions and how to manage dynamic monitoring lists in an operations context.
The article recounts a four‑year investigation that uncovered and repaired a subtle race‑condition bug in Python's Global Interpreter Lock, detailing the bug's origin, the implemented fixes, performance testing, and the decision to make the GIL creation unconditional in Python 3.7.
This article explains Python threading fundamentals, including thread context, kernel vs. user threads, the low‑level _thread module and the high‑level threading module, functional and class‑based thread creation, synchronization with locks, and using Queue for thread‑safe communication, all illustrated with complete code examples.
This article explains the fundamental differences between processes and threads, compares Thread and Runnable in Java, outlines thread lifecycle states, and details common concurrency methods such as sleep, join, yield, interrupt, wait, and synchronized, helping developers write robust multithreaded code.
This tutorial shows how to combine Python's threading and Queue modules to build a producer‑consumer multithreaded downloader for Tushare stock data, dramatically reducing download time from hours to under one hour.
This article explores five advanced Java thread topics—including naming, priority, ThreadLocal storage, daemon vs. user threads, and processor affinity—providing code examples, practical tips, and guidance for both beginners and seasoned developers.
The article explains how upgrading the Android NDK introduces threading pitfalls such as ANR and FindClass failures, and provides step‑by‑step solutions using main‑thread class lookup, global references, and thread attachment to safely execute JNI calls in background threads.
This article reviews Python threading fundamentals—including mutex locks and condition variables—explains their interaction, compares threading.Lock with threading.RLock, and presents a concise implementation of a thread‑safe task queue with illustrative diagrams and test code.
This article examines the internal implementation of the Android Picasso image‑loading library, detailing its singleton initialization, request creation, builder pattern usage, caching mechanisms, delayed loading, and the workflow of actions, handlers, and thread execution to illustrate how images are fetched and displayed.
This article explains how to combine MVP architecture with RxJava in Android development, covering framework selection, step‑by‑step MVP construction, thread management using RxJava, and practical Q&A on testing, modularization, and memory‑leak prevention, providing a comprehensive guide for building decoupled, responsive mobile apps.
This article explains Java thread scheduling, priority, and the distinct behaviors of the yield() and join() methods, providing code examples that illustrate how each method influences thread execution order and synchronization in multithreaded applications.
