An interview‑focused analysis explains how processes allocate resources, threads handle CPU scheduling, and coroutines act as lightweight user‑mode threads, comparing their creation costs, switching overhead, and memory usage, and highlights Java 19/21 virtual threads as the Java implementation of coroutines.
This article systematically explains why Linux processes may disappear, covering OOM Killer, signal termination, cgroup limits, systemd timeouts, manual kills, and provides step‑by‑step diagnostic commands and preventive measures for RHEL, AlmaLinux, and Ubuntu environments.
This article explains the definitions, internal structures, lifecycle, scheduling, communication mechanisms, and trade‑offs of processes, threads, and coroutines, helping readers master a frequent interview topic and choose the right concurrency model for their applications.
The article explains that although kill ‑9 reliably kills a Linux process, using it in production can cause severe data corruption—especially with non‑transactional storage engines—making it unsuitable for safe program termination.
When a cross‑team technical disagreement arises, an architect can defuse it by first understanding the full business context, clearly defining the core problem, mapping module responsibilities from a full‑link perspective, and establishing reusable standards to prevent future conflicts.
This article explains how the CPU executes instructions, the roles of processes and threads, the structure of a process control block, and the different types of context switches in Linux, highlighting why these mechanisms impact overall system performance.
A production engineer receives a P2 CPU‑load alert, diagnoses the offending Python backup script by inspecting top and ps outputs, discovers it was compressing a 350 GB log directory, and resolves the issue with a forced kill and post‑mortem best‑practice advice.
This article explains the ELF file format, its various types, internal structure, compilation and linking steps, and how the Linux kernel loads ELF binaries, creates processes with fork and exec, handles dynamic linking, relocation, and builds the process address space, providing developers and system engineers with deep insight into Linux execution.
This guide explains what port occupation means on Linux, demonstrates how to use lsof and netstat to pinpoint the process holding a specific port, and shows how to safely terminate that process to free the port for your applications.
This article explains the fundamental differences between processes, threads, coroutines, and virtual threads, shows how they are implemented in Java with code examples, compares their performance, and provides practical guidance on choosing the right concurrency model for various workloads.
This tutorial explains core Linux process concepts—including the difference between programs and processes, how to view and identify processes, detailed usage of fork and vfork for creating child processes, process termination, zombie and orphan handling, and practical examples of exec, system, and popen functions with C code.
This article explains the fundamental concepts of processes and threads, compares their definitions, lifecycles, advantages and disadvantages, and provides practical guidelines for choosing between multi‑processing and multi‑threading based on factors such as resource usage, performance, reliability, and application requirements.
This article explains Linux process concepts, creation methods like fork, vfork and clone, termination handling, and the inner workings of the Completely Fair Scheduler (CFS), including virtual runtime, red‑black tree organization, priority changes, and wake‑up compensation.
This article explains how the fork() system call creates a duplicate process in Linux, walks through a simple code experiment, details the kernel steps—including task_struct creation, PID allocation, copy-on-write memory handling, and resource inheritance—and highlights common use cases, optimizations, and pitfalls.
When a Linux process is terminated by SIGKILL, the sender cannot be identified directly, but by adding a small patch to kernel/signal.c that logs the killer's PID and command name, you can trace the source of the kill, compile and flash the kernel to verify the change.
The article examines how unrestricted wiki editing in companies leads to duplicated, outdated, and low‑quality documentation, contrasts this with the disciplined PR‑based workflow of open‑source projects like Python, and argues that effective documentation governance depends on clear processes and cultural support rather than just tools.
This article explains the fundamental concepts of processes and threads, their relationship, resource allocation, scheduling, communication methods, practical use cases, and interview preparation tips, helping readers choose between multiprocessing and multithreading for various scenarios.
This article explains how Linux processes are created, managed, and replaced using the fork, wait (including waitpid), and exec system calls, covering their prototypes, return values, copy‑on‑write optimization, and practical C code examples that demonstrate their coordinated use in real‑world scenarios.
This article outlines comprehensive stability assurance mechanisms—including standards, process workflows, the distinction between developers and SREs, personal responsibilities, and practical construction directions—to guide teams in building resilient, high‑availability systems through proactive, daily, and incident‑response practices.
A simple typo that changed a daily interest rate from 0.00006944444 to 0.00069444444 inflated calculated interest tenfold, went unnoticed because the author self‑approved the SQL update and testing only checked syntax, and the incident underscores the need for rigorous code review, testing, and change‑management procedures for critical data.
This guide explains Linux process concepts, how to view and trace processes with commands like ps and pstree, terminate them using kill, and schedule tasks both once with at and repeatedly with crontab, providing syntax, options, and practical examples.
This article explains what programs and processes are, details process states and types, shows how to view and control processes with commands like ps, top, pgrep, pstree, free, iostat, and iotop, and covers manual start, termination, and scheduling of tasks on Linux.
An in‑depth guide explains what a program and a process are, details the Linux task_struct fields, describes process states, creation functions like fork, vfork, clone, kthread_create, the do_fork core, copy‑on‑write, termination methods, and the roles of zombie, orphan, and init processes.
A developer mistakenly entered an extra zero in a SQL update for daily interest rates, expanding calculated interest by ten times, and the error slipped through code review, testing, and production verification due to inadequate processes, highlighting the need for strict data‑change procedures, thorough testing, and monitoring.
The article recounts a developer’s mistake of entering an extra decimal place in a SQL update for daily interest rates, explains how the error escaped code review, testing and production validation, and shares practical lessons on precision handling, review processes, and operational safeguards.
This article explains core operating system concepts—including its main functions, the distinction between user and kernel modes, process and thread management, and semaphore-based synchronization—providing clear definitions, code examples, and practical usage scenarios for developers.
This article explains how Linux creates processes using fork, vfork, clone and pthread_create, reveals the role of the init process, explores clone flags and namespace checks in the kernel, and shows why understanding these fundamentals demystifies container startup.
This guide outlines a comprehensive hardware R&D quality management process—from project initiation and requirement analysis to design reviews, testing, SPC, FMEA, and cost management—ensuring product reliability, stability, and competitive market performance.
An illustrated guide walks you through the five essential phases of the R&D lifecycle—Concept, Planning, Development, Verification, and Release—showing key activities at each stage and linking to further resources on metrics, standards, and best practices for effective product development.
This article explains why background loops in Bash scripts can survive script termination, demonstrates the problem with concrete examples, and provides robust solutions using trap, killall/pkill, and kill 0 to ensure all child processes exit together.
This guide explains Linux process concepts, how to list and inspect processes using ps and pstree, terminate them with kill or killall, and schedule one‑time or recurring tasks via the at and crontab utilities, complete with command syntax and examples.
This article explains how Google uses informal design documents to capture high‑level implementation strategies, trade‑offs, and consensus, outlining their structure, lifecycle, and when they add value versus when they become unnecessary overhead for software projects.
This comprehensive guide explains Python’s multiprocessing module, covering process creation, inter‑process communication, pools, synchronization primitives, error handling, and real‑world examples such as web crawlers, data analysis, and game servers, helping developers harness multiple CPU cores to boost performance and avoid GIL limitations.
This article explains the definition, characteristics, and structure of processes, describes process creation, termination, and state transitions, outlines various scheduling algorithms, and introduces inter‑process communication mechanisms such as pipes, sockets, shared memory, and message queues, with example C code for Linux.
This tutorial walks you through Linux process creation with fork, explains copy‑on‑write mechanics, details process termination, waiting, and program replacement using exec families, and culminates in building a basic shell, complete with code examples and visual illustrations.
This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.
This article explains what event tracking (埋点) is, its role in collecting user behavior data, the real‑time and offline data pipelines, the responsible teams, the end‑to‑end implementation process, common quality issues, detailed test cases, and the Track platform used for verification.
This article provides a comprehensive overview of Linux processes—from their definition and lifecycle to creation, scheduling strategies such as FCFS, round‑robin, EDF, and RMS, as well as various inter‑process communication mechanisms like pipes, sockets, shared memory, semaphores, and the kernel implementation of fork and context switching.
This document outlines a comprehensive Product/Project R&D Management System V3.0, detailing governance principles, requirement analysis, feasibility studies, design, development, testing, release, operation, documentation, cost control, and intellectual property management to ensure disciplined, high‑quality software delivery.
This article explains how a CPU fetches and executes instructions, how processes and threads are created and managed, and why thread pools are crucial for efficiently handling short‑lived tasks on modern multi‑core systems.
This article walks through a simple C program that forks a parent and child process, explains why they share the same virtual address for a global variable yet see different values, and details how Linux uses virtual memory, page tables, and copy‑on‑write to manage process address spaces.
This guide explains what a process is, how it differs from a thread, various ways to create and terminate processes in Linux, and provides detailed examples of inter‑process communication mechanisms—including message queues, shared memory, UNIX domain sockets, pipes, and semaphores—complete with C code samples.
This article analyzes high‑profile service outages, defines the production environment and its components, categorizes five types of production changes, and presents a comprehensive change‑management framework—including organizational roles, step‑by‑step procedures, and best‑practice tips—to help teams reduce risk and maintain system stability.
This guide walks you through essential Linux monitoring tools—htop/top for CPU usage, /proc files for hardware details, uptime and sar for load averages, pidstat for per‑process metrics, strace for system calls, lsof for open files, and network utilities like netstat and ss—providing commands, options, and interpretation tips to help you diagnose performance issues efficiently.
This article explains the PDCA (Plan‑Do‑Check‑Act) cycle—its origin, meaning of each letter, eight‑step framework, and how to apply it in product design, personal work logs, training, recruitment, and performance management—showing how continuous loops drive systematic improvement.
This article explains the concepts of processes and threads, their fundamental differences, how they relate to concurrency and parallelism, and details which resources are private to each thread versus shared across a process, using diagrams and real‑world factory analogies to aid understanding.
This guide explains how to use Linux tools such as htop, top, uptime, sar, strace, free, pidstat, lsof, and Docker commands to monitor CPU, load average, memory, processes, network throughput, socket states, and database connections, helping you diagnose performance issues and map container PIDs to host PIDs.
This article outlines a complete software testing workflow—including requirement analysis, technical review, test design, developer self‑testing, test involvement, gray release, and full launch—highlighting key activities, stakeholder participation, and best practices for ensuring quality throughout the development lifecycle.
This article explains the concepts of processes and threads, their differences and interactions, the states of a process, the distinctions between serial, concurrent, and parallel execution, and the purpose and operation of process pools in modern computing environments.
This article investigates Linux's handling of files that are in use—whether opened for reading, running as executables, or loaded as shared libraries—by experimenting with deletion, replacement, and modification, revealing how the kernel preserves file contents via inode references until all processes release them.
This article compiles real-world examples and practical guidance for identifying, assessing, and mitigating risks throughout the game development lifecycle, offering QA teams concrete strategies for risk definition, early estimation, and handling of demand, quality, process, testing, and operational challenges to improve overall risk management.
This article shares a two‑week experience of quickly learning and testing the after‑sales business for a QA engineer, outlining preparation steps, core B2C after‑sales workflow, demand analysis, and practical testing strategies for cross‑business tasks.
This article explains how ScrumXP, a lightweight process created by SAFe that blends Scrum and Extreme Programming, differs from the Scrum defined in the official Scrum Guide in terms of purpose, team structure, roles, events, values, and empirical foundations.
This article explains what Unix signals are, categorizes reliable and unreliable signals, describes how they are generated by hardware and software, and provides detailed examples of registration, blocking, pending states, and custom handling using C functions such as kill, sigprocmask, sigaction, and signal.
This article provides a deep, step‑by‑step exploration of Linux process creation, using Nginx’s worker forking as a concrete example, and walks through the task_struct layout, process states, PID management, address‑space handling, file system structures, namespaces, and the internal logic of the fork system call.
The article outlines how to define security requirements within business context, presents a security requirement vision (SRV) and strategic architecture principles, distinguishes security governance, management and operations, and describes a formalized security process framework—including ownership, documentation, integration matrices, roles, and automation opportunities—to guide consistent, traceable security solutions.
This article explains how Linux implements processes and threads, showing that both are represented by the same task_struct structure, detailing thread creation via pthread_create and clone, and comparing the kernel‑level steps—including flag handling, copy_process, and resource sharing—that differentiate threads from full processes.
From a programmer’s viewpoint, processes can be in three states—running (or ready), suspended (e.g., waiting for signals like SIGCONT after sleep or wait), and terminated (after exit or Ctrl+C), with explanations of how signals control transitions and what each state signifies.
The article outlines the definition, essential elements, types, and step‑by‑step process of communication within organizations, and proposes formal and informal mechanisms—including meetings, 1‑on‑1s, weekly reports, and knowledge platforms—to improve information flow, alignment, and team cohesion for better management outcomes.
This article analyzes the business challenges of marketing automation, introduces workflow concepts and models, compares workflow engines with state machines, presents popular open‑source engines, and details the design, core modules, interfaces, and practical considerations of a self‑built lightweight workflow engine.
This article explains how Linux creates the illusion of multitasking by rapidly swapping CPU registers and program counters, details the three types of context switches—process, thread, and interrupt—and shows why excessive switching can significantly degrade system performance.
This article explains why Linux treats every thread as a process, describes the core kernel data structures task_struct, thread_info and the kernel stack, details the clone‑based creation path, and clarifies virtual address spaces, page tables, and the differences between user processes and kernel threads.
This tutorial explains Linux process concepts, how to view and identify processes, the differences between programs and processes, and provides detailed examples of using fork, vfork, wait, exec family functions, system, and popen to create, control, and monitor child processes, including handling zombies and orphans.
This article explains the purpose of an agile team maturity model, highlights the unique mindset‑driven nature of agile, and proposes a preliminary PMTV (People, Mechanism, Tool, Value) framework with detailed assessment criteria for evaluating team capabilities and improvement opportunities.
This article analyzes why Linux reports "fork: cannot allocate memory" when the real issue is an excessive number of threads or PID allocation failures, explains the kernel's do_fork and alloc_pid implementations, and offers guidance for diagnosing and fixing such misleading ENOMEM errors.
The article outlines how to define security requirements within business context, presents strategic security architecture principles, distinguishes security governance, management and operations, and describes a formalized approach to documenting and integrating security processes for effective enterprise information security.
Technical leaders scaling teams beyond a hundred members can adopt a systematic R&D management framework—covering culture, processes, talent, tools, and strategic positioning—to align goals, boost efficiency, and sustain growth across fast‑moving businesses.
This article explains Linux processes and threads, their relationship, key kernel parameters like ulimit, threads‑max, and pid_max, and how to limit thread and PID usage in containers using cgroups, Docker, and Kubernetes to prevent resource exhaustion.
This article outlines the iterative seven‑step EA process for developing business architecture, details each phase from definition to migration planning, and explains how to design an effective operating model using five core elements such as leadership, governance, organization, capabilities, and services.
This article explains the differences between processes and threads, the advantages of using multiple processes in Python, and provides step‑by‑step code examples—including basic process creation, subclassing Process, inter‑process communication with queues, process pools, and a practical file‑copying case study—to help readers master multiprocessing for efficient concurrent programming.
This article explains the essential concepts of operating‑system processes, covering why they exist, their characteristics, lifecycle states, the role of the process control block, creation and termination steps, synchronization mechanisms, locks, deadlock solutions, and common inter‑process communication methods.
This article explains the Linux exec command, its syntax and options, provides practical examples, and expands on how exec replaces a process without creating a new PID, offering deeper insight into process management and system calls.
The article explains the fundamental differences between processes and threads, compares their performance and resource usage, and details various inter‑process and intra‑thread communication mechanisms such as pipes, semaphores, message queues, shared memory, sockets, and lock‑based synchronization.
This article provides a comprehensive overview of Node.js’s architecture, including its composition, code structure, startup process, event loop phases, process and thread management, core modules such as Cluster, libuv thread pool, signal handling, file operations, and networking protocols, illustrating how the runtime integrates V8 and operating‑system features.
This article explains Google’s design‑doc culture, detailing how informal yet structured documentation captures high‑level strategies, trade‑offs, and consensus, and outlines best‑practice sections, lifecycle steps, and when writing a design doc adds real value to software development.
This article explains core operating‑system concepts such as processes, threads, their control blocks and contexts, details how CPU, process, and thread context switches and system calls work on Linux, and shows how to analyze them with vmstat, pidstat, and sysbench for performance tuning.
This article explains the concepts of processes and threads, compares their characteristics, outlines their respective advantages and disadvantages, and provides practical guidelines for choosing between multithreading and multiprocessing in software design.
This article explains the fundamental concepts of processes and threads in operating systems, compares their characteristics, outlines their respective advantages and disadvantages, and provides practical guidelines for choosing between multi‑process and multi‑thread designs in real‑world applications.
This article explains how Node.js handles processes, demonstrates creating child processes with fork, illustrates inter‑process communication (IPC) using send and message events, explores handle passing and shared ports, and shows how to build robust clusters with the built‑in cluster module.
This article explains how Nginx runs as a daemon with a master process and multiple worker processes, why it prefers a multi‑process asynchronous non‑blocking architecture over threads, and details the key internal data structures such as connections, requests, arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees that enable its high‑performance HTTP handling.
This article explains Python's multiprocessing module, covering process concepts, creation of single and multiple processes, process pools, locks, inter‑process communication methods such as Event, Pipe, Queue, semaphores, and data sharing techniques, with code examples and visual illustrations.
Through a playful narrative, the article explains how Linux processes interact with the kernel, why blocking I/O is inefficient, and how the epoll system call and its associated mechanisms like soft interrupts and the scheduler dramatically improve network concurrency and performance.
This article narrates how a process interacts with sockets, the drawbacks of blocking reads, the shift to non‑blocking I/O, and the advantages of epoll’s multiplexing in Linux, illustrating the concepts with a humorous story and visual diagrams.
This article explains the concepts of processes and threads, their differences, interactions, state transitions, concurrency models, synchronous vs asynchronous execution, and the use of process pools to improve resource management and performance.
This article explains the Linux virtual file system (VFS) architecture, its role in abstracting concrete file systems, and details core kernel structures such as superblocks, inodes, dentries, file objects, and their relationships to processes, providing code examples and diagrams for clarity.
This step‑by‑step guide shows how to locate a Linux process frozen in uninterruptible sleep by using tools such as top, ps, WCHAN, /proc files, strace, pstack, and kernel stack traces to pinpoint the offending system call and its root cause.
This article explains the concepts of processes and threads, their differences, interaction methods, the three execution states of a task, synchronous and asynchronous communication, and the design and benefits of using a process pool to manage resources efficiently.
This article explains PHP's pcntl_fork() function, how it creates child processes on Linux, the return values in parent and child, code examples demonstrating variable copying and process multiplication, and clarifies why a loop with three forks results in seven child processes.
This article explains the concepts of processes and threads, their differences, interaction methods, the relationship between them, the three execution states of a task, the distinctions among parallel, concurrent, and serial execution, and the purpose and operation of process pools in operating systems.
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 presents a series of mind‑map diagrams that outline the fundamentals, processes, and tools for project communication management and stakeholder management, culminating in a comprehensive overall mind map, with a link to the full‑size image on the author's blog.
This article presents a series of mind‑map images that outline the concepts, processes, tools, documents, and overall framework of project human resource management, with a link to the full‑size diagram for deeper reference.
This article explains why QA should join technical design reviews, outlines the four main benefits, and provides a step‑by‑step guide for pre‑review preparation, in‑review focus areas, and post‑review follow‑up, illustrated with a real project case study.
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.
