Tagged articles
Interrupt
36 articles · Page 1 of 1
This article traces the complete lifecycle of a Java thread from new Thread() through start() to sleep and interrupt, revealing how the JVM creates OS threads via C++ JavaThread and OSThread objects, and demonstrating the 1:1 thread model with executable verification code.
1:1 Thread ModelConcurrencyInterrupt
0 likes · 13 min read

This article explains how LangGraph's interrupt() and Command mechanisms enable safe human‑in‑the‑loop approvals for risky AI actions such as data deletion, financial transfers, and email sending, balancing security with efficiency through a clear pause‑resume workflow.
AI workflowCommandInterrupt
0 likes · 6 min read

This article explains why AI agents need human‑in‑the‑loop checkpoints, introduces the interrupt() coroutine that freezes graph execution, shows how to embed it in tools and full graphs, compares three intervention modes, and provides production‑grade tips and common pitfalls.
AI agentsCheckpointerInterrupt
0 likes · 15 min read

This guide explains the concept of human‑in‑the‑loop (HITL) interruptions in LangGraph, outlines the core mechanisms such as persistent state and dynamic/static interrupts, and provides detailed Python examples for four classic patterns—approval/rejection, state editing, tool‑call review, and input validation—plus advanced topics like parallel interrupts and MCP‑based tool integration.
AI agentsInterruptLangGraph
0 likes · 35 min read

This article explains multiple techniques for terminating a Java thread—including using interrupt flags, checking thread state with isInterrupted(), handling InterruptedException, and why the deprecated stop() method is unsafe—providing code examples, output results, and cautions about lock release and data consistency.
ExceptionInterruptJava
0 likes · 12 min read

This article provides an in‑depth, step‑by‑step analysis of Linux GICv3 interrupt architecture, the kernel driver initialization, hardware‑to‑virtual interrupt mapping, the full interrupt handling state machine, and the workqueue subsystem including its data structures, initialization, and usage patterns.
Device TreeInterruptLinux
0 likes · 37 min read

This article clarifies the differences among Java’s thread interruption methods—interrupt(), Thread.interrupted(), and isInterrupted()—explaining how each affects a thread’s interrupt status, when exceptions are thrown, and how to properly monitor and handle interruptions in concurrent applications.
ConcurrencyInterruptJava
0 likes · 5 min read

This article explains step‑by‑step how a key press is detected by the keyboard controller, generates an interrupt, is handled by the kernel driver, written to a device file, and finally delivered to an X Window client via IPC.
IPCInterruptKeyboard
0 likes · 4 min read

When a key is pressed, the keyboard controller generates an interrupt that pauses the CPU, invokes the interrupt handler and driver to translate the scan code into a character, writes it to a device file, which the X server reads and forwards via IPC to the focused window.
IPCInterruptKeyboard
0 likes · 3 min read

The article explains why forcibly stopping a Java thread is unsafe, outlines common scenarios requiring thread exit, compares graceful and forced termination methods, and provides practical techniques such as flag checks and Thread.interrupt() with recommended interrupt‑handling strategies.
InterruptJavaThread
0 likes · 11 min read

The article explains that __disable_irq() and __enable_irq() are compiler‑provided intrinsics that expand to CPSID i and CPSIE i instructions, return the prior PRIMASK state, globally mask CPU interrupt handling without stopping hardware events, and contrasts them with CMSIS __NVIC_DisableIRQ/EnableIRQ which control individual interrupt lines.
ARMC++Embedded
0 likes · 7 min read

This article explains why forcibly stopping a Java thread is unsafe, outlines common scenarios that require thread termination, compares graceful and forced shutdown methods, and provides practical techniques—including flag checks and Thread.interrupt—to safely exit threads in Java applications.
InterruptThreadgraceful shutdown
0 likes · 11 min read

The article explains why forcibly stopping a Java thread is unsafe, outlines common scenarios that require thread exit, compares graceful and forced termination, and presents practical techniques such as flag checks and Thread.interrupt() to achieve safe and predictable thread shutdown.
BackendConcurrencyInterrupt
0 likes · 12 min read

The deprecated Thread.stop method should never be used; instead, Java threads are stopped gracefully by using a volatile stop flag or interrupting blocked threads, handling InterruptedException, and distinguishing between Thread.isInterrupted() (read‑only) and Thread.interrupted() (clears the flag).
ConcurrencyInterruptJava
0 likes · 4 min read

This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each technique with complete code examples, compares their effects on thread state, and warns about the dangers of forceful termination.
ExceptionInterruptMultithreading
0 likes · 12 min read

This article explains various ways to terminate a running Java thread, including using exit flags, the deprecated stop/suspend/resume methods, interrupt, handling InterruptedException, and the risks of forceful termination, accompanied by detailed code examples and best‑practice recommendations.
ConcurrencyDeprecated APIInterrupt
0 likes · 11 min read

This article explains various ways to terminate a running Java thread, comparing safe flag‑based exit, the deprecated stop/suspend/resume methods, and the recommended interrupt approach, while demonstrating how to detect interruption status, handle exceptions, and avoid common pitfalls with code examples.
ConcurrencyDeprecatedException
0 likes · 12 min read

This article explains the three ways to terminate a Java thread, demonstrates how interrupt flags and isInterrupted() differ, shows how to stop threads using exceptions, sleep interruption, and the deprecated stop() method, and warns about lock‑release issues caused by forceful termination.
ExceptionInterruptJava
0 likes · 12 min read

This article explains the principles, transfer modes, parameters, features, and register configuration of Direct Memory Access (DMA) in STM32 microcontrollers, illustrating how DMA offloads data movement from the CPU, improves performance, and integrates with peripherals, memory, and interrupt handling.
DMADirect Memory AccessInterrupt
0 likes · 16 min read

This article explains why Java does not provide a forced stop for threads, demonstrates how to use interrupt and various ThreadPool shutdown methods—including shutdown, isShutdown, isTerminated, awaitTermination, and shutdownNow—to safely terminate threads, and provides practical code examples.
InterruptShutdownThread
0 likes · 10 min read

Pressing a key triggers a complex chain of events—from the keyboard’s matrix circuit generating a keycode, through USB polling and kernel interrupt handling, to the X server reading device files, delivering the input to applications, and finally rendering the character on the screen via the framebuffer.
FramebufferInput HandlingInterrupt
0 likes · 6 min read

The article explains that Java lacks a safe preemptive way to stop threads and describes two cooperative cancellation mechanisms—using a volatile cancellation flag and using thread interruption—along with code examples and practical considerations for each approach.
CancellationConcurrencyInterrupt
0 likes · 5 min read

The article explains how the Linux kernel translates ARM GIC hardware interrupt numbers into virtual software IRQs by maintaining a global bitmap, initializing the interrupt controller, using irq_domain structures to map and associate hwirq and virq values, and storing relationships in descriptor and revmap trees for efficient lookup.
Device TreeIRQ MappingInterrupt
0 likes · 10 min read

This guide explains Linux kernel workqueues, their core structures and default system queues, shows how to use the schedule_work API, and walks through a complete driver example that captures the ESC key, queues a work item, and verifies execution via dmesg.
C++InterruptWorkqueue
0 likes · 11 min read

This article explains three ways to terminate a running Java thread—using an exit flag with volatile, the deprecated stop() method, and interrupt()—and provides detailed code examples, usage guidelines, and the pitfalls of each approach.
InterruptJavaStop
0 likes · 9 min read

This article explains why the Thread.stop and Thread.suspend methods were deprecated in modern Java, demonstrates the problems they cause with concrete code examples, and presents two safe alternatives—using a shared flag and the interrupt mechanism—to gracefully terminate threads without risking deadlocks or resource leaks.
ConcurrencyDeprecatedInterrupt
0 likes · 10 min read

This article explains why the historically used Thread.stop and Thread.suspend methods were deprecated in Java, illustrates their unsafe behavior with code examples, and demonstrates safer alternatives such as flag-controlled loops and the interrupt mechanism for graceful thread termination.
InterruptThreaddeprecation
0 likes · 12 min read


JD TechMar 26, 2021 · Frontend Development
This article explains how React 16 introduced the Fiber architecture to replace synchronous VDOM rendering, using operating‑system‑style interrupt mechanisms, RequestIdleCallback scheduling and task splitting to improve rendering performance and user experience in modern browsers.
FiberInterruptReact
0 likes · 8 min read

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.
Interruptcomputer architecturekernel
0 likes · 25 min read

This article explains how to properly stop a Java thread, compares deprecated Thread.stop() with interruption techniques, demonstrates checking a thread's interrupted state, shows how to use exceptions and return statements for graceful termination, and warns about the dangers of forceful stops and lock release.
ConcurrencyExceptionInterrupt
0 likes · 12 min read

This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each approach with code samples, compares Thread.interrupted() and isInterrupted(), and discusses the dangers of forceful termination and lock release.
ConcurrencyInterruptJava
0 likes · 12 min read

Through kernel‑level analysis we discovered that Redis packet loss stemmed from rx_dropped buffer exhaustion caused by interrupt‑handling backlogs, and resolved it by assigning NIC interrupts to specific cores on one NUMA node while binding Redis processes to the other, eliminating loss under dual‑10 GbE load.
InterruptLinux kernelNAPI
0 likes · 33 min read

This article provides a comprehensive introduction to Java multithreading, covering its historical background, thread lifecycle states, two ways to create threads, code examples for shared and non‑shared data, synchronization with the synchronized keyword, thread control methods such as interrupt, sleep, suspend, yield, priority settings, and daemon threads, concluding with key takeaways.
InterruptJavaMultithreading
0 likes · 18 min read


ITPUBSep 16, 2016 · Fundamentals
This article explains the purpose and mechanics of process sleep in the Linux kernel, describes how wait queues and wake‑up functions operate, and details why sleeping in interrupt context or while holding spinlocks, seqlocks, or RCU locks leads to deadlocks and system crashes.
InterruptLinuxSleep
0 likes · 16 min read


ITPUBAug 29, 2016 · Fundamentals
This article explains Linux interrupt handling mechanisms, covering the basic vector‑table approach, the need for bottom‑half processing, and the three main techniques—softirqs, tasklets, and workqueues—while highlighting their advantages, SMP support, and proper usage guidelines.
InterruptSMPTasklet
0 likes · 9 min read

This article explains Linux kernel interrupt handling, top‑half and bottom‑half mechanisms, IRQ request/release, shared IRQs, disabling/enabling IRQs, tasklets, workqueues, softirqs, the timer API, and provides a complete character‑device driver example with a user‑space test program.
C++InterruptLinux
0 likes · 16 min read
