Learn what Linux processes are, explore their various states—including running, ready, blocked, zombie, and orphan—understand how PID and PPID work, and discover practical C code examples and signal‑handling techniques to prevent and clean up zombie processes safely.
This guide explains how to keep Linux processes running despite SSH disconnections or terminal closures by using &, nohup, job control commands, and the screen utility, complete with syntax examples and practical tips.
Even when the `df` command shows a full disk, hidden deleted files held open by processes can consume space, and understanding this requires diving into Linux’s virtual file system architecture, including superblocks, inodes, file and dentry objects, as well as link types and file‑process interactions.
This article introduces Python process concepts, including process creation with the multiprocessing module, process states, comparison with threads, and practical examples of creating, managing, and communicating with processes, followed by a comprehensive overview of Python list types, their structure, operations, and common usage patterns.
This article explains how to troubleshoot fragmented log files caused by the Supervisor process manager on Linux, covering configuration details, log‑rotation constraints, diagnostic commands, and the eventual resolution by restarting the supervisord service.
This tutorial demonstrates how to integrate Spring Boot with the Activiti workflow engine, covering essential operations such as querying tasks, suspending, activating, and deleting process instances, and provides complete Java code snippets and controller endpoints for each function.
This guide explains what zombie processes are, how they are created when a child exits before its parent reaps it, and provides practical commands and sample C code to reproduce and safely remove zombie processes on a Linux system.
apache_child_terminate() is a PHP function that registers the current Apache child process for termination after the request finishes, returning TRUE only when running under non‑threaded Apache with the child_terminate directive enabled, otherwise returning FALSE and emitting an E_WARNING.
Learn how to safely interrupt running commands, quit editors like Vim and Nano, exit paging tools such as less, and close the Linux terminal itself using simple keyboard shortcuts and commands, with clear examples for each scenario.
This article explains the classic three‑ and five‑state process models, Linux task_struct states, orphan and zombie processes, and how Docker and Kubernetes handle process IDs, providing practical solutions to prevent and clean up zombie processes in container environments.
This article explains why Go programs that spawn child processes can leave orphaned processes after a kill, and demonstrates two robust solutions: creating a new process group with syscall.Kill and using Linux prctl (via CGO or RawSyscall) to ensure child processes terminate when the parent exits.
This article summarizes Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, while illustrating each concept with diagrams and practical observations from recent reading notes.
This article explains the four core parts of a Linux system—kernel, shell, filesystem and applications—covering memory and process management, VFS architecture, file types, directory hierarchy, partitioning, mounting, links and essential command‑line tools.
This article describes how Ctrip Finance tackled data governance challenges by adopting the OneData methodology to standardize metric definitions, unify data warehouse modeling, and systematize process management, ultimately improving data quality, reducing redundancy, and supporting rapid business growth.
This article explains why processes are preferred over threads for stability and multi‑machine distribution, introduces Python's multiprocessing.managers for networked task queues, and provides step‑by‑step code examples to create a distributed crawler that fetches image URLs and downloads them across several machines.
This guide demonstrates how to integrate Spring Boot with the Activiti workflow engine, covering common operations such as querying owner tasks, retrieving assigned tasks, suspending, activating, and deleting process instances, complete with controller examples and sample API calls.
This article explains why Docker containers often stop right after starting, covering the role of PID 1, daemon‑off mode, Linux process management concepts like zombie and orphan processes, and how Docker’s containerd‑shim and runC interact to keep containers alive.
This article explains Nginx's multi‑process design, the roles of master, worker, and cache processes, how to view and control them with Linux signals and command‑line tools, and the step‑by‑step reload procedure that ensures zero‑downtime configuration updates.
This article provides a comprehensive cheat‑sheet of the 21 most frequently asked Linux commands, covering file navigation, content viewing, searching, permissions, text processing, archiving, system control, and process management for interview preparation and daily use.
This guide explains how to use the ps and grep commands to identify zombie processes on Linux, interpret the output fields, and terminate them safely by sending signals to the appropriate parent or child processes, with example commands and verification steps.
This article shares practical definitions of collaboration and efficiency, explains the balance between output and capacity, and introduces four reusable table templates that streamline requirement communication, design review, and iteration tracking, helping teams save time, reduce friction, and improve overall workflow effectiveness.
This guide explains how Linux treats programs and daemons as processes, shows how to list them with ps using various options, demonstrates extracting Chromium process IDs, and provides safe techniques for terminating unwanted processes with kill, killall, and advanced options, while warning about careful use.
This article introduces BPMN as an industry‑standard notation for modeling business processes, outlines its key benefits such as stakeholder clarity and vendor neutrality, and explains the five core element categories—swimlanes, flow elements, connecting objects, data, and artifacts—through descriptive text and illustrative diagrams.
This comprehensive guide covers over forty operating system interview questions, explaining core concepts such as OS fundamentals, process and thread management, memory handling, file systems, I/O mechanisms, scheduling algorithms, and deadlock prevention, providing detailed answers and diagrams to help candidates excel in technical interviews.
This article explains Nginx's high‑performance architecture, covering its daemon mode with master and worker processes, the thundering‑herd problem, advantages of process‑based concurrency, asynchronous non‑blocking I/O, connection handling, keep‑alive and pipeline techniques, as well as key internal data structures such as arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees.
This article traces the historical shift in software development practices, comparing the linear Waterfall model with Agile, Kanban, Scrum, and Lean approaches, highlighting how each methodology improves flexibility, transparency, and efficiency by borrowing principles from automotive production systems.
This article introduces the powerful cross‑platform psutil module, explains how to install it, demonstrates basic commands to list processes, retrieve CPU usage, and explore various useful methods, all illustrated with clear code snippets and screenshots.
This article introduces Python’s sys and os modules, detailing their most useful functions for runtime configuration, file and path manipulation, process control, and environment handling, and provides clear code examples—including a simple progress bar and a demonstration of sys.argv versus __file__ behavior—to help readers master essential system programming techniques.
This article explains the distinction between kernel space and user space in a 32‑bit Linux system, covering address layout, privilege levels, mode transitions, system calls, and the overall OS structure to illustrate how separating these spaces enhances stability and security.
The article explains how a company can achieve a process‑oriented organization by defining business flow, aligning processes, leveraging IT to solidify data handling, integrating quality standards, and establishing continuous operations, emphasizing the need for clear concepts and roles across the enterprise.
This guide shows how to use the ps command combined with grep to list zombie processes, explains each option, demonstrates killing the identified zombies with kill -HUP, and provides tips for verifying removal and using top to monitor processes.
This article explains how a 32‑bit operating system divides its 4 GB address space into kernel and user regions, why this separation protects system stability, how kernel and user modes differ, and the mechanisms—such as system calls—that let processes move between them.
This comprehensive guide breaks down the four main parts of a Linux system—kernel, shell, filesystem and applications—detailing kernel subsystems such as memory and process management, shell variants, file types, directory hierarchy, partition handling, VFS, mounting procedures, link types and essential command‑line tools, while also touching on application bundles and kernel parameter tuning.
This article explains how a user‑level program becomes a Linux process, how the kernel views it through ELF loading, the role of the task_struct data structure, its key fields, task state transitions, and how the kernel stores the descriptor in memory.
This guide walks you through Linux process fundamentals and equips you with practical commands—ps, strace, pstack, pstree, gdb, and /proc file inspection—to diagnose, trace, and debug running programs step by step.
This guide compiles the most frequently used Linux commands for file navigation, content viewing, searching, permission handling, text processing, archiving, system control, and process management, providing clear examples that help operations staff work more efficiently and confidently.
This article explains the true meaning of the Linux kill command, the differences between signals like SIGTERM and SIGKILL, the risks of using kill -9 for abrupt termination, and how to implement graceful shutdowns in Java and shell scripts.
The article explains the semantics of the Linux kill command, why using kill -9 for abrupt termination is risky, how to prefer SIGTERM (kill -15) for graceful shutdowns, shows Java shutdown‑hook usage, and provides a shell script that automates safe process termination.
This guide explains how to use the Linux ps and grep commands to identify zombie processes, interpret their status fields, and safely terminate them with kill -HUP, including steps to verify removal and alternative methods using top.
This article introduces BPMN as an industry‑standard notation for modeling business processes, outlines its key benefits, describes the five basic element categories—including swimlanes, flow elements, connectors, data, and artifacts—and previews a multi‑part tutorial with visual examples.
This guide explains how to install Supervisor via pip or yum, configure supervisord.conf and a Laravel worker configuration file, handle common errors, set permissions, and start and manage Laravel queue workers using supervisorctl on a Linux system.
This guide explains how to install Nginx on a Linux server, manage it with systemctl commands, verify its operation using netstat, and control related processes via ps and kill utilities, providing practical command examples for each step.
This guide walks through installing Supervisor on CentOS 7, configuring its core settings, creating program definitions for Tomcat and Redis, and managing services with supervisord and supervisorctl, providing a reliable solution for automatic process recovery on Linux/Unix systems.
This guide walks you through installing Supervisor on CentOS 7.6, configuring its core settings, creating process definitions for Tomcat and Redis, and using supervisorctl and systemd to start, stop, and monitor these services, ensuring automatic recovery on failure.
This comprehensive guide explains over 190 fundamental operating system and computer architecture concepts—including OS kernels, memory management, process control, virtualization, storage, networking, and security—providing clear definitions, examples, and visual illustrations to help readers grasp the core building blocks of modern computing systems.
This article explains why many agile retrospectives become lengthy and ineffective, analyzes the root causes, and provides a step‑by‑step PDCA‑based framework—including pre‑meeting preparation, meeting design, execution, and follow‑up—to ensure actionable improvement items are planned, executed, checked, and acted upon.
This article explains what Linux zombie processes are, why the kernel retains them after a program exits, the crucial information they store, and demonstrates how to create, observe, and properly clean up zombies using C code and standard system calls.
This article explains why nohup cannot monitor scripts, introduces Supervisor as a Python‑based process monitor, shows how to install it on CentOS, Ubuntu, and via pip, details the supervisord.conf and program .ini configurations, demonstrates a sample Python script, and outlines common commands for managing and restarting services.
Discover ten powerful yet underused Linux commands—including pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—explaining their purposes, typical usage examples, and practical tips for effective system administration.
This article explains what a Linux zombie process is, why it remains after a child exits, what information it retains, how it affects system resources, and provides a complete C example with compilation and command‑line steps to observe and clean up zombies.
This guide walks you through Linux’s top command, explaining its default output—including system uptime, load averages, task summary, CPU states, memory usage, and column fields—while detailing the full set of interactive keys and command‑line options for real‑time process monitoring and management.
This guide explains the Linux top command in depth, covering its default output fields, how to interpret system uptime, load averages, task summaries, CPU and memory statistics, as well as the full set of interactive keys and command‑line options for customizing monitoring.
This article outlines a detailed software development workflow—including requirement review, technical design review, coding, code review, testing, deployment, and post‑release retrospection—providing practical checklists, templates, and best‑practice recommendations to improve product quality and team efficiency.
This article explains how zombie processes remain in the Linux process table after a program calls exit, what information they retain, why they cannot be killed directly, and how to properly reap them using wait or waitpid.
This comprehensive guide explains the fundamentals of operating systems, covering hardware components, CPU architecture, memory hierarchy, process and address space management, file systems, system calls, and various OS structures such as monolithic, layered, microkernel, and client‑server designs, providing clear examples and diagrams for each concept.
This article examines classic smooth upgrade strategies for HTTP services, highlights their limitations, and provides a detailed analysis of Facebook’s graceful restart library for Go, including code examples, signal handling, process inheritance, and the mechanisms for zero‑downtime deployments.
This article outlines the design, architecture, and key features of an IBPM workflow platform, detailing its background, core concepts, design principles, extensibility, and future direction for creating a configurable, integrated, and intelligent business process management solution.
Fkill, a cross‑platform Node.js CLI tool, lets you interactively search and terminate multiple processes; this guide shows how to install it via AUR or npm, use its interactive UI, kill processes by PID, name or port, and leverage command‑line options for force, verbose, or silent modes.
The article explores how natural evolution drives automation and intelligence, argues that effective process management combined with solid technical implementation is essential for internet companies, and outlines a DevOps methodology—including execution and observation systems, toolchains, and performance metrics—to achieve high efficiency and competitive advantage.
Youzan introduced a semi‑annual OKR‑driven value‑loop management system that aligns company, business‑line, and project teams around prioritized demands, tracks expected versus actual outcomes, and enables transparent, end‑to‑end value flow for efficient resource allocation and continuous improvement.
Youzan’s Efficiency Improvement team shares how they boost R&D and organizational efficiency by continuously optimizing goal‑oriented value streams, implementing end‑to‑end product demand lifecycles, enforcing engineering fundamentals, measuring delivery lead time, applying project‑management best practices, and productizing processes through an integrated Efficiency Platform built on system‑thinking principles.
This comprehensive guide explains the core components of a Linux system—including the kernel, memory management, process scheduling, device drivers, networking, shells, file‑system types, VFS architecture, mounting procedures, and link handling—providing clear examples, commands, and diagrams for each topic.
This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.
This article explains how Nginx creates and controls its master and worker processes using Linux signals, global flag variables, and a series of initialization steps—including signal handling, process spawning, socketpair communication, and worker loop execution—to achieve robust, high‑concurrency request handling.
This article shares a set of operational Murphy’s laws, practical process‑management tips, and automation strategies to help ops engineers reduce human error, improve safety, stability, efficiency, and cost‑saving in daily work.
On Linux, this guide shows how to locate and terminate a Java background process using ps and kill, then explains why force‑killing can leave resources open, and provides a complete Java SignalHandler implementation to receive termination signals, safely close files, database connections, and Kafka consumers.
This guide shows how to run a simple PHP script that prints a line every second, demonstrates the effects of Ctrl+C (SIGINT) and session termination (SIGHUP), and explains how to use the shell background operator (&), nohup, and their combination to control output and process termination.
This article explains how buffer zones in a Kanban board help identify bottlenecks, illustrates the problem with limited WIP using a case study, and provides practical steps to set up transition states as buffers to improve overall workflow efficiency.
This guide shows several ways to start Python graphical applications—by renaming scripts to .pyw, using batch files, or building a PyQt5 launch toolbox—so you can run them instantly without opening a black command‑prompt window.
The article presents a lively debate at the annual "Zuo Chan Lun Dao" conference where seasoned practitioners contrast the Waterfall and Agile development models, discussing requirements management, quality control, and process management to illustrate the strengths and trade‑offs of each approach.
The article dramatizes a debate between the Waterfall and Agile development approaches, illustrating their differing philosophies on requirements, quality control, and process management, and concludes that each method has unique strengths, urging teams to select the most suitable practice based on project needs.
This article details Ctrip's mobile app release practice, covering the organizational structure, step‑by‑step release workflow, the MCD continuous delivery platform, key success factors, and insights drawn from years of large‑scale mobile deployment across dozens of business units.
This article explains Linux process management fundamentals, covering process concepts, lifecycle, threads, priorities, context switches, interrupt handling, process states, memory layout, and the O(1) CPU scheduler, providing clear diagrams and practical insights for developers and system engineers.
This article explains Linux process management fundamentals, covering process concepts, lifecycle, threads, priorities, context switches, interrupts, process states, memory layout, and the O(1) scheduler, with clear diagrams to help readers understand kernel behavior and performance impact.
This guide shows how to identify which users are logged into a Linux system, examine their current actions with commands like who, users, w, and last, and safely terminate unwanted sessions using pkill, providing practical examples and detailed output explanations.
This article provides a detailed source‑code analysis of RePlugin's process management, covering process startup, attachBaseContext handling, IPC initialization, PMF setup, plugin installation, synchronization across processes, and the internal mechanisms for loading and updating plugins.
This article explains how the Linux nohup command lets a process continue running after the terminal is closed, demonstrates it with an infinite-loop PHP script, and clarifies why the jobs command cannot list background tasks across different sessions.
This guide explains four Python techniques for executing and managing external Windows programs—including os.system, win32api ShellExecute, win32process CreateProcess, and ctypes calls to kernel32.dll—providing code signatures, parameter details, and practical examples.
This article explores the multifaceted role of IT operations, emphasizing how automation, documentation, processes, monitoring, and backup strategies create business value, and shares practical insights from over ten years of experience to help professionals elevate their operational impact.
This article explains how Linux server programs run as daemons, handle logging with syslog/rsyslog, manage user identities, control process groups and sessions, enforce resource limits, and change working directories, providing practical guidance for robust backend operations.
This article explains what a Linux process is, how the kernel schedules multiple processes, the nature and dangers of zombie processes, techniques to prevent them, and the fundamentals of multithreading, including thread creation, scheduling, priorities, and synchronization issues.
This article explains the internal architecture of PHP‑FPM, covering its startup sequence, master‑worker process management, event‑driven loop, signal handling, shared‑memory scoreboard implementation, and the overall request lifecycle, with detailed code excerpts and diagrams.
This guide walks you through Linux’s top command, explaining its real‑time output—including system load, tasks, CPU and memory usage—and details every interactive key (h, d, f, k, etc.) and command‑line option for customizing displays, sorting, and managing processes.
This guide explains how to terminate unresponsive Linux applications using the kill family of commands, covering signal types, command syntax, PID discovery, and advanced tools like pkill, killall, and xkill, with practical examples and safety tips.
The Spring Project team adopted Scrum and a physical Kanban board, combined with TFS work items, to streamline requirement tracking, code‑story linkage, version control, and automated deployment, resulting in clearer process management, higher delivery quality, and improved team efficiency across fifteen iterations.
An in‑depth guide to Linux process management covering process concepts, lifecycle, threads, priority, context switching, interrupt handling, process states, memory layout, and the O(1) scheduler, illustrated with diagrams to help readers understand kernel behavior and performance implications.
This article explains the design, components, and implementation of UCloud's application hot‑patch framework, covering its motivation, safety checks, multi‑thread support, and how the Creator, Loader, and Core Runtime work together to apply, manage, and roll back patches without restarting services.
Node.js’s child_process core module enables creation of child processes to leverage multi‑core CPUs and inter‑process communication, while also allowing execution of external files or system commands; this article explores the differences and inner workings of its exec and spawn methods.
This article explains the limitations of traditional Node.js master/worker process models, introduces Pandora.js's procfile.js definition for flexible process orchestration, and demonstrates how to configure, scale, and monitor processes using concise code examples.
This article provides a comprehensive overview of Linux system architecture, covering the kernel, shell, file system, memory management, process scheduling, device drivers, networking, partitioning, mounting, and common command‑line tools, offering readers a solid foundation in operating‑system fundamentals.
Discover the ten most common Linux kernel processes, from memory management with kswapd0 to I/O handling by aio, and learn how each thread functions, why they appear in brackets, and what role they play in system performance and stability.
The article explains why an Android app may start several processes, causing Application.onCreate() to execute multiple times, and presents various techniques—including android:process configuration, process‑specific initialization, getRunningAppProcesses(), UsageStatsManager, and the AndroidProcesses library—to reduce startup latency and manage running processes across different Android versions.
This article explains the concepts of zombie and orphan processes in Unix/Linux, analyzes a real‑world PHP‑FPM incident where thousands of zombie processes exhausted system resources, and presents diagnostic steps, testing procedures, and preventive coding practices to avoid such issues.
This guide compiles eleven powerful Linux terminal shortcuts and commands—including cursor editing keys, sudo shortcuts, background job control, nohup, at scheduling, man page tweaks, htop, ranger, shutdown cancellation, process killing, REISUB, and youtube‑dl—designed to boost productivity and streamline everyday command‑line tasks.
This article explains how Linux server programs run as daemons, covering logging mechanisms, syslog usage, user and group IDs, process groups and sessions, resource limit management, and techniques for changing working directories and chrooting.
This guide explains how Nginx modules are organized, how to view and select available modules with ./configure --help, add third‑party modules using the --add-module option, and understand Nginx’s single‑process and master‑worker process models.
Learn how to effectively use the Linux killall command to terminate processes, including basic usage, case‑insensitive matching, interactive prompts, quiet mode, signal selection, and handling long‑named processes, with step‑by‑step examples and visual illustrations.
This article explains how to use the Linux top command for real‑time system and process monitoring, covering its interface, statistical and process sections, interactive shortcuts, command‑line options, and internal commands to customize and sort the displayed information.
This guide walks through essential Linux process‑monitoring tools—ps, top, and htop—detailing their options and output fields, and explains process control techniques using kill, killall, and job‑control commands, helping readers efficiently view, sort, and manage system processes.
This article explains php-fpm’s three process management modes—ondemand, dynamic, and static—detailing their operation principles, configuration requirements, and the advantages and disadvantages of each for high‑traffic web services.
