This comprehensive guide covers the fundamentals of processes and threads, their definitions, relationships, creation, lifecycle, scheduling strategies, context switching, inter‑process communication methods, and practical C/C++ examples, providing a deep dive into operating‑system concepts for developers and interview preparation.
This article introduces fundamental operating‑system concepts—including processes, address spaces, file systems, I/O devices, protection mechanisms, and virtual memory—explaining their roles, state models, and how they enable reliable communication between hardware and application software.
This article explains the concepts of kernel space and user space in a 32‑bit OS, why they are separated, the distinction between kernel mode and user mode, how processes transition between them, and the overall Linux system structure.
This article provides a comprehensive, step‑by‑step explanation of Linux fundamentals—including the kernel architecture, process and thread creation, memory management, filesystem structures, I/O handling, and built‑in security mechanisms—illustrated with code snippets and diagrams.
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 core operating system concepts—CPU as a factory, the static nature of programs versus dynamic processes, how threads act as workers on production lines, and synchronization mechanisms like mutexes and semaphores, using clear analogies and diagrams.
This article outlines a practical four‑step process—Define, Scope, Experiment, Analyze—to help DevOps engineers prioritize automation tasks, assess pain points, and align improvements with business value, offering actionable guidance for effective pipeline and workflow optimization.
This article explains the operating‑system concepts of processes, threads, and coroutines, compares their performance with Python code examples, discusses the impact of the GIL and DMA, and provides clear guidelines for choosing the right concurrency model based on CPU‑bound, I/O‑bound, or mixed workloads.
This article explains the fundamental concepts of operating systems, describing how the CPU functions as a factory, the distinction between static programs and dynamic processes, the role of threads, and synchronization mechanisms such as mutexes, semaphores, and inter‑process communication.
This article explains the concepts of processes, their identifiers, the fork system call, and the differences between orphan and zombie processes, providing code examples, output analysis, and practical ways to handle each situation on Unix‑like systems.
Spotify shares a three‑step, product‑focused approach—prioritization, productized migration, and automation—to streamline large‑scale technical upgrades, avoid fragmented legacy systems, and keep engineering teams focused on core business value.
This guide explains the PHP pclose() function, its signature, how it closes a process opened with popen(), the required handle parameter, the return values indicating the process termination status, and provides a clear example demonstrating its correct usage.
This article outlines the iterative EA process for building business architecture, details each of the seven EBA development steps—from definition and scope to migration planning and optimization—and explains the five essential components of an effective operating model, providing practical guidance for enterprise architects.
This article explains operating system fundamentals such as process and thread definitions, time‑slice preemptive scheduling, process features and lifecycle, thread characteristics, priority handling, multi‑core execution models, and synchronization mechanisms like mutexes and semaphores.
This article provides a comprehensive guide to Python's multiprocessing module, covering how to create and manage processes, use join for synchronization, configure daemon processes, and employ synchronization primitives such as Lock, Semaphore, Event, and Queue for safe inter‑process communication, with complete code examples.
This article details the step‑by‑step process of creating FaceTeam, a systematic brand illustration framework for the 58 platform, covering its inception, design principles, component integration, and how it boosts visual consistency and production efficiency across multiple business lines.
This article explains what a process is, how it differs from a program, outlines its key characteristics, clarifies concurrency versus parallelism, describes how to create child processes, and covers orphan and zombie processes, termination methods, process groups, sessions, and race conditions.
This article summarizes a DevOps best‑practice talk, explaining how the VUCA environment and hidden "gray rhino" risks demand five critical success factors—goal alignment, people & culture, process, platform, and technology—and offers practical steps for enterprises to start and mature their DevOps journey.
This article provides a comprehensive overview of operating system fundamentals and computer architecture, covering topics such as OS components, kernel and user modes, memory management, process handling, hardware interfaces, storage hierarchies, virtualization, and related historical and modern systems in roughly eighty concise entries.
This article explains what a process is, distinguishes it from a program, outlines its key characteristics, describes how multiple processes are created, and covers special cases such as orphan and zombie processes, termination methods, process groups, sessions, and race conditions in operating systems.
This article explains Node.js's internal concurrency model, covering the distinction between processes and threads, debunking the single‑thread myth, and detailing how the event loop, child processes, cluster mode, and worker_threads enable high‑performance, multi‑core execution.
This article explains the definitions of processes and threads, outlines their key differences—including resource allocation, address space, and scheduling overhead—and uses a train‑carriage analogy to deepen understanding of their relationship and interaction in operating systems.
This article explains the concepts of processes and threads in Python, compares multi‑process, multi‑thread, and combined approaches, shows how to use fork, the multiprocessing module, process pools, subprocesses, and inter‑process communication with queues, and provides complete code examples with results.
This guide explains how to use Java's Runtime API within a UiAutomator test to start, filter, and safely terminate an adb logcat process, including a complete Logcat thread implementation and tips for preventing oversized log files.
This article explains how the Agricultural Bank's R&D Center uses TFS for end‑to‑end requirement itemization, detailing the workflow of project, module, and function work items, the importance of standardized information entry, and guidelines for demand batch and change number documentation.
This article explains how to create and manage multiple processes in Python using the os.fork method, the multiprocessing module's Process and Pool classes, and demonstrates inter‑process communication with Queue and Pipe, providing clear code examples for both Unix/Linux and cross‑platform environments.
The article examines the common friction between testers and developers, likening it to the Prisoner's Dilemma, identifies typical sources of conflict such as unclear processes, standards, resource contention, and attitudes, and offers five practical strategies to improve communication, workflow, and teamwork for better software quality.
This comprehensive guide walks experienced front‑end developers through the browser's multi‑process model, internal threading, rendering pipeline, JavaScript single‑threaded execution, event loop mechanics, Web Workers, and performance‑related concepts like macrotasks, microtasks, and hardware‑accelerated compositing.
The article presents a straightforward DevOps value framework that emphasizes business needs over architecture, and explores how people, processes, tools, principles, methods, and practices interrelate, arguing that thoughtful, economical architectural decisions and unified technology stacks are essential for startups navigating rapid change.
This article explains Linux process fundamentals—including creation, the PCB, scheduling, and the emergence of zombie processes—details their causes and removal methods, and then compares processes with threads, covering multithreading implementation, issues, classifications, priorities, and synchronization techniques.
This article explains the purpose of software architecture design, identifies sources of complexity such as performance, availability and scalability, outlines three guiding principles—appropriateness, simplicity, and evolution—and presents a practical step‑by‑step design process illustrated with diagrams.
This article explains Linux process fundamentals, scheduling, the creation of zombie processes, their causes, and practical methods to avoid them, while also comparing processes and threads and discussing multithreading concepts and synchronization techniques.
Drawing on ten years of experience at leading firms like NetEase, Baidu, and Tencent, the author shares practical insights on the critical role of development processes, disciplined coding, pragmatic architecture, effective bug handling, and regular self‑review for software teams.
The article explores common conflicts between development, testing, and operations staff, explains why operations are often undervalued, and offers practical steps—such as clear documentation, defined processes, and proactive communication—to improve teamwork and reduce blame‑shifting in software projects.
The article chronicles Google’s Test Certified initiative from its 2006 inception, detailing its three original levels, certification process, expansion efforts, cultural impact, and both positive and negative aspects, illustrating how a grassroots testing program reshaped engineering practices and code quality across the company.
This article explains the concepts of processes and threads, their historical development, and how Java implements multithreading and synchronization using techniques like extending Thread, implementing Runnable, and applying the synchronized keyword to ensure thread safety.
This article reflects on the core concepts of DevOps, Lean, and Agile, describing the dual-loop model of work and system, the roles, processes, and tools needed for effective implementation, and emphasizing that the ultimate goal is delivering value through the right people, methods, and actions.
The article uses martial‑arts metaphors to explore how operations engineers should master fundamentals, combine inner knowledge with practical skills, leverage tools, embrace teamwork, and automate processes to deliver higher business availability with lower cost.
Learn how to use the Linux ps command with the etime and etimes options to display the elapsed runtime of a specific process on an Ubuntu server, including finding the PID, formatting the output, and hiding headers for clean results.
This article explains the core role of Android Activity, how it interacts with users, obtains context, saves state, handles configuration changes, switches with services, details its lifecycle stages, and describes the related process priority levels in the Android system.
This article explains the fundamental role of Android Activity as the primary UI component, its interaction with layouts and context, how it saves state, handles configuration changes, switches with services, and details its complete, visible, and foreground lifecycles as well as the various process priority levels in Android.
The article uses three vivid workplace anecdotes to illustrate why clear goals, feasible methods, solid communication, rational processes, proper incentives, and effective assessment are essential for turning strategy into successful execution.
This article explains how to use Python's multiprocessing module to achieve true parallelism, covering Process creation, inter‑process synchronization primitives such as Lock, Semaphore, Event, communication tools like Queue and Pipe, and advanced patterns with Pool, all illustrated with runnable code examples.
This article explains what processes and threads are, how they relate, their key differences, and the advantages and disadvantages of each, helping readers grasp why multithreading can boost efficiency while processes offer stronger isolation and fault tolerance.
This article explains the differences between code, programs, and processes in Linux, demonstrates how to compile and run a simple program, explores parent‑child relationships, the role of the init process, the process lifecycle, and the copy‑on‑write mechanism.
