Tagged articles
Signal Handling
36 articles · Page 1 of 1
This article explains Linux signal fundamentals—including generation, registration, dispatch, masking, and handling—covers standard and real‑time signals, common pitfalls like non‑reentrancy and EINTR, and provides concrete C/C++ code examples for each scenario.
C++LinuxPOSIX
0 likes · 44 min read

This guide explains what a Core Dump is, why it is essential for Linux crash analysis, how the kernel creates it, common signals that trigger it, typical causes of crashes, and step‑by‑step configuration and GDB techniques to capture and debug Core Dump files effectively.
ELFSignal Handlingcore dump
0 likes · 37 min read

This article explains why proper signal handling is crucial for Go services, details common Unix signals, demonstrates common pitfalls, and provides a robust, context‑driven approach with code examples for graceful termination, including Kubernetes considerations.
BackendGoKubernetes
0 likes · 10 min read

This article explains how to perform a graceful shutdown of Java services by using Linux kill signals, configuring JVM SignalHandler and Runtime shutdown hooks, releasing resources such as thread pools and sockets, and exposing a Spring Boot Actuator endpoint for controlled termination, complete with code examples and configuration details.
JVMJavaSignal Handling
0 likes · 16 min read

This article explains the challenges of Android app crashes and presents a comprehensive, cloud‑native solution that captures both Java/Kotlin and native crashes, details the underlying mechanisms such as UncaughtExceptionHandler, signal handling, minidump generation, stack unwinding, and offers practical guidance for integrating reliable crash reporting into mobile applications.
AndroidCrash ReportingJava
0 likes · 19 min read

This article explains how to achieve graceful shutdown for Java applications by using Linux kill signals, JVM SignalHandler registration, Runtime.addShutdownHook, and Spring Boot's actuator shutdown endpoint, providing code examples and configuration details for safe resource cleanup.
JavaRuntime HookSignal Handling
0 likes · 13 min read

Starting with Kubernetes v1.33, the Alpha feature ContainerStopSignals introduces a Pod‑level lifecycle.stopSignal field that lets platform teams specify which Unix signal (e.g., SIGINT, SIGUSR1) should be sent to containers on termination, overcoming the previous reliance on image‑defined STOPSIGNAL and improving graceful shutdown control across Linux and Windows workloads.
Alpha FeatureContainerStopSignalsKubernetes
0 likes · 6 min read

This guide explains why graceful shutdown matters in Go programs, outlines the steps to capture termination signals, use context for coordinated goroutine exit, and properly close HTTP servers without data loss or resource leaks.
ConcurrencyContextHTTP server
0 likes · 9 min read

During a gray‑release, a Go‑Rust service repeatedly crashed when a dependent process was hot‑upgraded; the root cause was an unhandled SIGPIPE signal generated by the kernel on a broken TCP connection, which terminated the process without a core dump, and the article explains the kernel mechanics and the solution of ignoring SIGPIPE.
GoLinux signalsRust
0 likes · 16 min read

This article explains how the Linux SIGPIPE signal is generated during broken TCP connections, why the default kernel handling can terminate Go services that call Rust code via cgo, and provides practical code examples to ignore SIGPIPE and avoid silent process exits.
GoLinux signalsRust
0 likes · 15 min read

This article explains how the SIGPIPE signal is generated in Linux, why it can cause Go‑Rust services to crash without a core dump, and how to prevent it by configuring the signal handler to ignore SIGPIPE.
GoLinuxRust
0 likes · 15 min read

This article explains how to implement graceful shutdown for Go programs, covering signal handling with os/signal, closing HTTP servers without interrupting active connections, managing goroutine lifecycles, and providing complete example code for both the standard net/http package and the Gin framework.
GoSignal Handlinggraceful shutdown
0 likes · 44 min read

This article explains how Go's os/signal and os packages enable programs to listen for and handle Unix signals such as SIGINT and SIGTERM, providing step-by-step code examples, detailed breakdown of each component, and discussion of practical use cases and challenges for graceful termination.
GoSignal Handlinggraceful shutdown
0 likes · 5 min read

This article introduces the Go‑based G.S library for graceful application shutdown, analyzes common container‑related pitfalls, explains its lightweight architecture with TerminateSignal and WaitingUnit modules, provides installation steps, a complete usage example, and detailed code explanations to help developers implement reliable signal handling.
LibrarySignal Handlinggraceful shutdown
0 likes · 12 min read

This comprehensive guide explains how to containerize Java applications by choosing appropriate base images, deciding between JDK and JRE, selecting a JVM, handling graceful shutdown signals, configuring memory limits, managing DNS caching, and optionally compiling to native binaries with GraalVM.
ContainerizationDockerJVM
0 likes · 23 min read

This guide explains Linux serial port device files, shows how to list them, and provides four C programming methods—polling, select‑based interrupt, SIGIO signal handling, and threaded reading—complete with code examples and detailed configuration steps.
C++Device FilesLinux
0 likes · 10 min read

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.
C++LinuxSignal Handling
0 likes · 18 min read

This article explains how Android native developers can capture and recover from controllable SIGSEGV crashes by registering signal handlers and using sigsetjmp/siglongjmp to emulate a try‑catch mechanism, complete with sample JNI code and practical considerations.
AndroidJNINative Crash
0 likes · 12 min read

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.
Process ManagementSignal Handlingorphan process
0 likes · 13 min read

This article explains how Android captures ANR events by intercepting the SIGQUIT signal, covering the relevant signal‑handling functions (kill, signal, sigaction, sigwait, pthread_sigmask), their differences, the SignalCatcher thread implementation, and how developers can create custom SIGQUIT monitors for ANR analysis.
ANRAndroidC++
0 likes · 15 min read

This article explains the Android ANR workflow, analyzes the system's appNotResponding logic, and presents a robust monitoring strategy that captures SIGQUIT signals, validates true ANR events, and hooks trace writes to reliably detect and diagnose ANRs in mobile apps.
ANRAndroidPerformance Monitoring
0 likes · 22 min read

This article provides a comprehensive guide to Bash scripting, covering conditional statements (if/elif/else), case selections, various loop constructs (for, while, until, select), loop control commands, parameter shifting, signal trapping with trap, and includes numerous practical code examples with detailed analysis.
ConditionalsLoopsSignal Handling
0 likes · 17 min read

This article provides a detailed Bash scripting tutorial covering conditional statements (if/elif/else, case), various loop constructs (for, while, until, select), control commands (break, continue, shift), signal handling with trap, and several practical example scripts such as a multiplication table, colored triangle, and chessboard pattern.
ConditionalsLoopsSignal Handling
0 likes · 16 min read

This article explains the concepts of reentrant and thread‑safe functions, their differences, how signals affect them, examples of non‑reentrant scenarios, and practical guidelines for writing safe code in C on Unix-like systems.
POSIXSignal Handlingc-programming
0 likes · 14 min read

This article explains how Android native exceptions (NE) are captured, processed, and logged as tombstone files, detailing the signal registration, debuggerd workflow, crash_dump execution, unwinder backtrace generation, and how developers can analyze the resulting data using tools like addr2line.
AndroidDebuggingNative Crash
0 likes · 11 min read

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.
GoHTTP serverProcess Management
0 likes · 15 min read

This article explains how to capture and report both Java and native crashes on Android using the Eagle Eye monitoring system, detailing the use of Thread.UncaughtExceptionHandler, Linux signal mechanisms, sigaction registration, alternative stacks, and native stack parsing with libbacktrace to improve app stability.
AndroidCrash MonitoringEagle Eye
0 likes · 12 min read

xCrash is an open‑source Android SDK that reliably captures both Java and native crashes across Android 4.0‑9.0 and multiple CPU architectures by using async‑signal‑safe handlers, a dedicated dumper process, and pre‑allocated resources to generate tombstone‑style dump files without root, offering richer diagnostics than BreakPad and extensible future features.
AndroidCrash ReportingNative
0 likes · 17 min read

This tutorial explains how to implement hot‑reloading of Go configuration files by manually sending Unix signals, covering the creation of a signal‑listening goroutine, use of the signal.Notify API, selective handling with select, and a complete example that loads JSON config on SIGUSR1.
ConfigurationGoSignal Handling
0 likes · 10 min read

To implement a graceful hot restart for a Go HTTP service, the program listens for SIGHUP, forks a child process that inherits the listening socket via an extra file descriptor, the parent stops accepting new connections and shuts down while the child begins serving, ensuring uninterrupted client requests.
GoHot ReloadProcess Fork
0 likes · 10 min read

This comprehensive guide walks you through Bash scripting fundamentals, covering conditional statements (if, case), four types of loops (for, while, until, select), loop control commands, signal trapping with trap, useful one‑liners, and a collection of fun mini‑scripts, all illustrated with clear examples and diagrams.
ConditionalsLinuxLoops
0 likes · 11 min read

This article explains how to capture and analyze native crashes on Android by using signal handlers, alternate stacks, and tools like dladdr and ptrace, while also showing how to retrieve Java stack traces and integrate crash information for robust mobile debugging.
Native CrashSignal Handlingmobile development
0 likes · 24 min read

To prevent loss of asynchronous tasks and data corruption during application restarts, this article explains how to safely shut down the JVM using shutdown hooks, custom signal handling, and proper hook implementation, while highlighting risks of forced termination and best‑practice considerations.
BackendJVMJava
0 likes · 12 min read


ITPUBNov 5, 2016 · Fundamentals
This article explains what zombie processes are in Linux, how they are created when a child exits without its parent calling wait, demonstrates their detection with ps, provides sample C code to reproduce and handle them, and shows techniques to avoid their accumulation.
C++Process ManagementSignal Handling
0 likes · 8 min read


ITPUBJul 1, 2016 · Fundamentals
This article explains how Linux signals work, why the original signal() API behaved as a one‑shot handler, how modern glibc’s signal() maps to rt_sigaction with safer flags, and demonstrates the differences with code samples, strace traces, and kernel source snippets.
LinuxSignal HandlingSignals
0 likes · 17 min read


21CTOJun 11, 2016 · Operations
A deep dive into a long‑standing PHP‑CGI deadlock that left deleted log files occupying disk space, explaining how signal‑unsafe functions caused the lock, how the issue was diagnosed with lsof, strace and gdb, and the practical steps to eliminate the deadlock.
CGILinuxOperations
0 likes · 8 min read
